hogan_assets 1.0.0

data/.gitignore

@@ -0,0 +1,16 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/.rvmrc

@@ -0,0 +1 @@
+rvm use @hogan_assets

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in hogan_assets.gemspec
+gemspec

data/Gemfile.lock

@@ -0,0 +1,27 @@
+PATH
+  remote: .
+  specs:
+    hogan_assets (1.0.0)
+      execjs (>= 1.2.9)
+      sprockets (>= 2.0.3)
+      tilt (>= 1.3.3)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    execjs (1.2.13)
+      multi_json (~> 1.0)
+    hike (1.2.1)
+    multi_json (1.0.4)
+    rack (1.3.5)
+    sprockets (2.1.2)
+      hike (~> 1.2)
+      rack (~> 1.0)
+      tilt (~> 1.1, != 1.3.0)
+    tilt (1.3.3)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  hogan_assets!

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2011 Les Hill
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,64 @@
+# HoganAssets
+
+**HoganAssets** compiles your [mustache](http://mustache.github.com/) templates with [hogan.js](http://twitter.github.com/hogan.js/) on **sprockets** and the Rails asset pipeline.
+
+**hogan.js** is a templating engine developed at [Twitter](http://twitter.com) that follows the **mustache** spec and compiles the templates to JavaScript. The first bit is *cool*, since `mustache` is *cool*. The second bit is **awesome and full of win** because we can now compile our **mustache** templates on the server using the asset pipeline/sprockets.
+
+This gem contains **hogan.js v1.0.2**
+
+## Installation
+
+### Installation with Rails 3.1+
+
+Add this to your `Gemfile` as part of the `assets` group
+
+    group :assets do
+      gem 'hogan_assets'
+    end
+
+And then execute:
+
+    $ bundle
+
+Require `hogan.js` somewhere in your JavaScript manifest, for example in `application.js` if you are using Rails 3.1+:
+
+    //= require hogan.js
+
+Locate your `.mustache` templates with your other JavaScript assets, usually in `app/assets/templates` or `app/assets/javascripts/templates`.
+Require your templates with `require_tree`:
+
+    //= require_tree templates
+
+Templates are named for the sub-path below `require_tree`. For example, the file `app/assets/javascripts/templates/pages/person.mustache` will be named `pages/person`.
+
+### Installation with sprockets
+
+Add this line to your `Gemfile`:
+
+    gem 'hogan_assets'
+
+And then execute:
+
+    $ bundle
+
+Require `hogan.js` somewhere in your JavaScript.
+
+*TODO* Templates?
+
+## Usage
+
+Templates are compiled to a global JavaScript object named `HoganTemplates`. To render `pages/person`:
+
+    HoganTemplates['pages/person'].render(context, partials);
+
+# Author
+
+I made this because I <3 **mustache** and want to use it in Rails. Follow me on [Github](https://github.com/leshill) and [Twitter](https://twitter.com/leshill).
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Added some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,8 @@
+#!/usr/bin/env rake
+require 'bundler/gem_tasks'
+require 'rake/testtask'
+
+Rake::TestTask.new do |t|
+  t.libs << 'test'
+  t.test_files = FileList['test/**/*_test.rb']
+end

data/hogan_assets.gemspec

@@ -0,0 +1,21 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/hogan_assets/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["Les Hill"]
+  gem.email         = ["leshill@gmail.com"]
+  gem.description   = %q{Use compiled hogan.js (mustache) JavaScript templates with sprockets and the Rails asset pipeline.}
+  gem.summary       = %q{Use compiled hogan.js (mustache) JavaScript templates with sprockets and the Rails asset pipeline.}
+  gem.homepage      = ""
+
+  gem.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  gem.files         = `git ls-files`.split("\n")
+  gem.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  gem.name          = "hogan_assets"
+  gem.require_paths = ["lib"]
+  gem.version       = HoganAssets::VERSION
+
+  gem.add_runtime_dependency "execjs", ">= 1.2.9"
+  gem.add_runtime_dependency "tilt", ">= 1.3.3"
+  gem.add_runtime_dependency "sprockets", ">= 2.0.3"
+end

data/lib/hogan_assets.rb

@@ -0,0 +1,13 @@
+require 'hogan_assets/version'
+
+module HoganAssets
+  autoload(:Hogan, 'hogan_assets/hogan')
+  autoload(:Tilt, 'hogan_assets/tilt')
+
+  if defined?(Rails)
+    require 'hogan_assets/engine'
+  else
+    require 'sprockets'
+    Sprockets.register_engine '.mustache', Tilt
+  end
+end

data/lib/hogan_assets/engine.rb

@@ -0,0 +1,8 @@
+module HoganAssets
+  class Engine < ::Rails::Engine
+    initializer "sprockets.hogan", :after => "sprockets.environment", :group => :all do |app|
+      next unless app.assets
+      app.assets.register_engine('.mustache', Tilt)
+    end
+  end
+end

data/lib/hogan_assets/hogan.rb

@@ -0,0 +1,31 @@
+# Based on https://github.com/josh/ruby-coffee-script
+require 'execjs'
+require 'pathname'
+
+module HoganAssets
+  class Hogan
+    class << self
+      def compile(source)
+        context.eval("Hogan.compile(#{source.inspect}, {asString: true})")
+      end
+
+      private
+
+      def context
+        @context ||= ExecJS.compile(source)
+      end
+
+      def source
+        @source ||= path.read
+      end
+
+      def path
+        @path ||= assets_path.join('javascripts', 'hogan.js')
+      end
+
+      def assets_path
+        @assets_path ||= Pathname(__FILE__).dirname.join('..','..','vendor','assets')
+      end
+    end
+  end
+end

data/lib/hogan_assets/tilt.rb

@@ -0,0 +1,25 @@
+require 'tilt'
+
+module HoganAssets
+  class Tilt < Tilt::Template
+    self.default_mime_type = 'application/javascript'
+
+    def evaluate(scope, locals, &block)
+      compiled_template = Hogan.compile(data)
+      code = data.inspect
+      template_name = scope.logical_path.inspect
+      <<-TEMPLATE
+        (function() {
+          this.HoganTemplates || (this.HoganTemplates = {});
+          this.HoganTemplates[#{template_name}] = new HoganTemplate(#{code});
+          this.HoganTemplates[#{template_name}].r = #{compiled_template};
+          return HoganTemplates[#{template_name}];
+        }).call(this);
+      TEMPLATE
+    end
+
+    protected
+
+    def prepare; end
+  end
+end

data/lib/hogan_assets/version.rb

@@ -0,0 +1,3 @@
+module HoganAssets
+  VERSION = "1.0.0"
+end

data/test/hogan_assets/tilt_test.rb

@@ -0,0 +1,25 @@
+require 'test_helper'
+
+module HoganAssets
+  class TiltTest < Test::Unit::TestCase
+    def test_mime_type
+      assert_equal 'application/javascript', HoganAssets::Tilt.default_mime_type
+    end
+
+    def test_render
+      scope = Class.new do
+        def logical_path ; 'path/to/template' ; end
+      end.new
+
+      template = HoganAssets::Tilt.new('/myapp/app/assets/templates/path/to/template.mustache') { "This is {{mustache}}" }
+      assert_equal <<END_EXPECTED, template.render(scope, {})
+        (function() {
+          this.HoganTemplates || (this.HoganTemplates = {});
+          this.HoganTemplates["path/to/template"] = new HoganTemplate("This is {{mustache}}");
+          this.HoganTemplates["path/to/template"].r = function(cx,p){var c = [cx];var b = "";var _ = this;b += "This is ";b += (_.v(_.f("mustache",c,p,0)));return b;;};
+          return HoganTemplates["path/to/template"];
+        }).call(this);
+END_EXPECTED
+    end
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,4 @@
+require 'hogan_assets/tilt'
+require 'hogan_assets/hogan'
+
+require 'test/unit'

data/vendor/assets/javascripts/hogan.js

@@ -0,0 +1,514 @@
+/*
+ *  Copyright 2011 Twitter, Inc.
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *  http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+var HoganTemplate = (function () {
+
+  function constructor(text) {
+    this.text = text;
+  }
+
+  constructor.prototype = {
+    // render: replaced by generated code.
+    r: function (context, partials) { return ''; },
+
+    // variable escaping
+    v: hoganEscape,
+
+    render: function render(context, partials) {
+      return this.r(context, partials);
+    },
+
+    // tries to find a partial in the curent scope and render it
+    rp: function(name, context, partials, indent) {
+      var partial = partials[name];
+
+      if (!partial) {
+        return '';
+      }
+
+      return partial.render(context, partials);
+    },
+
+    // render a section
+    rs: function(context, partials, section) {
+      var buf = '',
+          tail = context[context.length - 1];
+
+      if (!isArray(tail)) {
+        buf = section(context, partials);
+        return buf;
+      }
+
+      for (var i = 0; i < tail.length; i++) {
+        context.push(tail[i]);
+        buf += section(context, partials);
+        context.pop();
+      }
+      return buf;
+    },
+
+    // maybe start a section
+    s: function(val, ctx, partials, inverted, start, end) {
+      var pass;
+
+      if (isArray(val) && val.length === 0) {
+        return false;
+      }
+
+      if (!inverted && typeof val == 'function') {
+        val = this.ls(val, ctx, partials, start, end);
+      }
+
+      pass = (val === '') || !!val;
+
+      if (!inverted && pass && ctx) {
+        ctx.push((typeof val == 'object') ? val : ctx[ctx.length - 1]);
+      }
+
+      return pass;
+    },
+
+    // find values with dotted names
+    d: function(key, ctx, partials, returnFound) {
+
+      var names = key.split('.'),
+          val = this.f(names[0], ctx, partials, returnFound),
+          cx = null;
+
+      if (key === '.' && isArray(ctx[ctx.length - 2])) {
+        return ctx[ctx.length - 1];
+      }
+
+      for (var i = 1; i < names.length; i++) {
+        if (val && typeof val == 'object' && names[i] in val) {
+          cx = val;
+          val = val[names[i]];
+        } else {
+          val = '';
+        }
+      }
+
+      if (returnFound && !val) {
+        return false;
+      }
+
+      if (!returnFound && typeof val == 'function') {
+        ctx.push(cx);
+        val = this.lv(val, ctx, partials);
+        ctx.pop();
+      }
+
+      return val;
+    },
+
+    // find values with normal names
+    f: function(key, ctx, partials, returnFound) {
+      var val = false,
+          v = null,
+          found = false;
+
+      for (var i = ctx.length - 1; i >= 0; i--) {
+        v = ctx[i];
+        if (v && typeof v == 'object' && key in v) {
+          val = v[key];
+          found = true;
+          break;
+        }
+      }
+
+      if (!found) {
+        return (returnFound) ? false : "";
+      }
+
+      if (!returnFound && typeof val == 'function') {
+        val = this.lv(val, ctx, partials);
+      }
+
+      return val;
+    },
+
+    // higher order templates
+    ho: function(val, cx, partials, text) {
+      var t = val.call(cx, text, function(t) {
+        return Hogan.compile(t).render(cx);
+      });
+      var s = Hogan.compile(t.toString()).render(cx, partials);
+      this.b = s;
+      return false;
+    },
+
+    // higher order template result buffer
+    b: '',
+
+    // lambda replace section
+    ls: function(val, ctx, partials, start, end) {
+      var cx = ctx[ctx.length - 1],
+          t = val.call(cx);
+
+      if (val.length > 0) {
+        return this.ho(val, cx, partials, this.text.substring(start, end));
+      }
+
+      if (typeof t == 'function') {
+        return this.ho(t, cx, partials, this.text.substring(start, end));
+      }
+      return t;
+    },
+
+    // lambda replace variable
+    lv: function(val, ctx, partials) {
+      var cx = ctx[ctx.length - 1];
+      return Hogan.compile(val.call(cx).toString()).render(cx, partials);
+    }
+  };
+
+  var rAmp = /&/g, rLt = /</g, rGt = />/g, rApos =/\'/g,
+      rQuot = /\"/g, hChars =/[&<>\"\']/;
+  function hoganEscape(str) {
+    var s = String(str === null ? '' : str);
+      return hChars.test(s) ? s.replace(rAmp,'&amp;')
+                   .replace(rLt,'&lt;').replace(rGt,'&gt;')
+                   .replace(rApos,'&#39;').replace(rQuot, '&quot;') : s;
+  }
+
+  var isArray = Array.isArray || function(a) {
+    return Object.prototype.toString.call(a) === '[object Array]';
+  };
+
+  return constructor;
+})();
+
+var Hogan = (function () {
+
+  // Setup regex  assignments
+  // remove whitespace according to Mustache spec
+  var rIsWhitespace = /\S/,
+      rQuot = /\"/g,
+      rNewline =  /\n/g,
+      rCr = /\r/g,
+      rSlash = /\\/g,
+      tagTypes = {
+        '#': 1, '^': 2, '/': 3,  '!': 4, '>': 5,
+        '<': 6, '=': 7, '_v': 8, '{': 9, '&': 10
+      };
+
+  function scan(text) {
+    var len = text.length,
+        IN_TEXT = 0,
+        IN_TAG_TYPE = 1,
+        IN_TAG = 2,
+        state = IN_TEXT,
+        tagType = null,
+        tag = null,
+        buf = '',
+        tokens = [],
+        seenTag = false,
+        i = 0,
+        lineStart = 0,
+        otag = '{{',
+        ctag = '}}';
+
+    function addBuf() {
+      if (buf.length > 0) {
+        tokens.push(new String(buf));
+        buf = '';
+      }
+    }
+
+    function lineIsWhitespace() {
+      var isAllWhitespace = true;
+      for (var j = lineStart; j < tokens.length; j++) {
+        isAllWhitespace =
+          (tokens[j].tag && tagTypes[tokens[j].tag] < tagTypes['_v']) ||
+           (!tokens[j].tag && tokens[j].match(rIsWhitespace) === null);
+        if (!isAllWhitespace) {
+          return false;
+        }
+      }
+
+      return isAllWhitespace;
+    }
+
+    function filterLine(haveSeenTag, noNewLine) {
+      addBuf();
+      if (haveSeenTag && lineIsWhitespace()) {
+        for (var j = lineStart; j < tokens.length; j++) {
+          if (!tokens[j].tag) {
+            tokens.splice(j, 1);
+          }
+        }
+      } else if (!noNewLine) {
+        tokens.push({tag:'\n'});
+      }
+
+      seenTag = false;
+      lineStart = tokens.length;
+    }
+
+    function changeDelimiters(text, index) {
+      var close = '=' + ctag,
+          closeIndex = text.indexOf(close, index),
+          delimiters = trim(text.substring(text.indexOf('=', index) + 1,
+                                           closeIndex)).split(' ');
+      otag = delimiters[0];
+      ctag = delimiters[1];
+      return closeIndex + close.length - 1;
+    }
+
+    for (i = 0; i < len; i++) {
+      if (state == IN_TEXT) {
+        if (tagChange(otag, text, i)) {
+          --i;
+          addBuf();
+          state = IN_TAG_TYPE;
+        } else {
+          if (text.charAt(i) == '\n') {
+            filterLine(seenTag);
+          } else {
+            buf += text.charAt(i);
+          }
+        }
+      } else if (state == IN_TAG_TYPE) {
+        i += otag.length - 1;
+        tag = tagTypes[text.charAt(i + 1)];
+        tagType = tag ? text.charAt(i + 1) : '_v';
+        seenTag = i;
+        if (tagType == '=') {
+          i = changeDelimiters(text, i);
+          state = IN_TEXT;
+        } else {
+          if (tag) {
+            i++;
+          }
+          state = IN_TAG;
+        }
+      } else {
+        if (tagChange(ctag, text, i)) {
+          i += ctag.length - 1;
+          tokens.push({tag: tagType, n: trim(buf),
+                       i: (tagType == '/') ? seenTag - 1 : i + 1});
+          buf = '';
+          state = IN_TEXT;
+          if (tagType == '{') {
+            i++;
+          }
+        } else {
+          buf += text.charAt(i);
+        }
+      }
+    }
+
+    filterLine(seenTag, true);
+
+    return tokens;
+  }
+
+  function trim(s) {
+    if (s.trim) {
+      return s.trim();
+    }
+
+    return s.replace(/^\s*|\s*$/g, '');
+  }
+
+  function tagChange(tag, text, index) {
+    if (text.charAt(index) != tag.charAt(0)) {
+      return false;
+    }
+
+    for (var i = 1, l = tag.length; i < l; i++) {
+      if (text.charAt(index + i) != tag.charAt(i)) {
+        return false;
+      }
+    }
+
+    return true;
+  }
+
+  function buildTree(tokens, kind, stack, customTags) {
+    var instructions = [],
+        opener = null,
+        token = null;
+
+    while (tokens.length > 0) {
+      token = tokens.shift();
+      if (token.tag == '#' || token.tag == '^' ||
+          isOpener(token, customTags)) {
+        stack.push(token);
+        token.nodes = buildTree(tokens, token.tag, stack, customTags);
+        instructions.push(token);
+      } else if (token.tag == '/') {
+        if (stack.length === 0) {
+          throw new Error('Closing tag without opener: /' + token.n);
+        }
+        opener = stack.pop();
+        if (token.n != opener.n && !isCloser(token.n, opener.n, customTags)) {
+          throw new Error('Nesting error: ' + opener.n + ' vs. ' + token.n);
+        }
+        opener.end = token.i;
+        return instructions;
+      } else {
+        instructions.push(token);
+      }
+    }
+
+    if (stack.length > 0) {
+      throw new Error('missing closing tag: ' + stack.pop().n);
+    }
+
+    return instructions;
+  }
+
+  function isOpener(token, tags) {
+    for (var i = 0, l = tags.length; i < l; i++) {
+      if (tags[i].o == token.n) {
+        token.tag = '#';
+        return true;
+      }
+    }
+  }
+
+  function isCloser(close, open, tags) {
+    for (var i = 0, l = tags.length; i < l; i++) {
+      if (tags[i].c == close && tags[i].o == open) {
+        return true;
+      }
+    }
+  }
+
+  function generate(tree, text, options) {
+    var code = 'var c = [cx];var b = "";var _ = this;' +
+               walk(tree) + 'return b;';
+    if (options.asString) {
+      return 'function(cx,p){' + code + ';}';
+    }
+
+    var template = new HoganTemplate(text);
+    template.r = new Function('cx', 'p', code);
+    return template;
+  }
+
+  function esc(s) {
+    return s.replace(rSlash, '\\\\')
+            .replace(rQuot, '\\\"')
+            .replace(rNewline, '\\n')
+            .replace(rCr, '\\r');
+  }
+
+  function chooseMethod(s) {
+    return (~s.indexOf('.')) ? 'd' : 'f';
+  }
+
+  function walk(tree) {
+    var code = '';
+    for (var i = 0, l = tree.length; i < l; i++) {
+      var tag = tree[i].tag;
+      if (tag == '#') {
+        code += section(tree[i].nodes, tree[i].n, chooseMethod(tree[i].n),
+                        tree[i].i, tree[i].end);
+      } else if (tag == '^') {
+        code += invertedSection(tree[i].nodes, tree[i].n,
+                                chooseMethod(tree[i].n));
+      } else if (tag == '<' || tag == '>') {
+        code += partial(tree[i].n);
+      } else if (tag == '{' || tag == '&') {
+        code += tripleStache(tree[i].n, chooseMethod(tree[i].n));
+      } else if (tag == '\n') {
+        code += text('\n');
+      } else if (tag == '_v') {
+        code += variable(tree[i].n, chooseMethod(tree[i].n));
+      } else if (tag === undefined) {
+        code += text(tree[i]);
+      }
+    }
+    return code;
+  }
+
+  function section(nodes, id, method, start, end) {
+    return 'if(_.s(_.' + method + '("' + esc(id) + '",c,p,1),' +
+           'c,p,0,' + start + ',' + end + ')){' +
+           'b += _.rs(c,p,' +
+           'function(c,p){ var b = "";' +
+           walk(nodes) +
+           'return b;});c.pop();}' +
+           'else{b += _.b; _.b = ""};';
+  }
+
+  function invertedSection(nodes, id, method) {
+    return 'if (!_.s(_.' + method + '("' + esc(id) + '",c,p,1),c,p,1,0,0)){' +
+           walk(nodes) +
+           '};';
+  }
+
+  function partial(id) {
+    return 'b += _.rp("' +  esc(id) + '",c[c.length - 1],p);';
+  }
+
+  function tripleStache(id, method) {
+    return 'b += (_.' + method + '("' + esc(id) + '",c,p,0));';
+  }
+
+  function variable(id, method) {
+    return 'b += (_.v(_.' + method + '("' + esc(id) + '",c,p,0)));';
+  }
+
+  function text(id) {
+    return 'b += "' + esc(id) + '";';
+  }
+
+  return ({
+    scan: scan,
+
+    parse: function(tokens, options) {
+      options = options || {};
+      return buildTree(tokens, '', [], options.sectionTags || []);
+    },
+
+    cache: {},
+
+    compile: function(text, options) {
+      // options
+      //
+      // asString: false (default)
+      //
+      // sectionTags: [{o: '_foo', c: 'foo'}]
+      // An array of object with o and c fields that indicate names for custom
+      // section tags. The example above allows parsing of {{_foo}}{{/foo}}.
+      //
+      options = options || {};
+
+      var t = this.cache[text];
+      if (t) {
+        return t;
+      }
+      t = generate(this.parse(scan(text), options), text, options);
+      return this.cache[text] = t;
+    }
+  });
+})();
+
+// Export the hogan constructor for Node.js and CommonJS.
+if (typeof module !== 'undefined' && module.exports) {
+  module.exports = Hogan;
+  module.exports.Template = HoganTemplate;
+} else if (typeof exports !== 'undefined') {
+  exports.Hogan = Hogan;
+  exports.HoganTemplate = HoganTemplate;
+}
+
+// Expose Hogan as an AMD module.
+if (typeof define === 'function' && define.amd) {
+    define(function () { return Hogan; });
+}

metadata

@@ -0,0 +1,98 @@
+--- !ruby/object:Gem::Specification
+name: hogan_assets
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+  prerelease: 
+platform: ruby
+authors:
+- Les Hill
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2011-12-25 00:00:00.000000000Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: execjs
+  requirement: &70131289224740 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 1.2.9
+  type: :runtime
+  prerelease: false
+  version_requirements: *70131289224740
+- !ruby/object:Gem::Dependency
+  name: tilt
+  requirement: &70131289224240 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 1.3.3
+  type: :runtime
+  prerelease: false
+  version_requirements: *70131289224240
+- !ruby/object:Gem::Dependency
+  name: sprockets
+  requirement: &70131289223780 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 2.0.3
+  type: :runtime
+  prerelease: false
+  version_requirements: *70131289223780
+description: Use compiled hogan.js (mustache) JavaScript templates with sprockets
+  and the Rails asset pipeline.
+email:
+- leshill@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rvmrc
+- Gemfile
+- Gemfile.lock
+- LICENSE
+- README.md
+- Rakefile
+- hogan_assets.gemspec
+- lib/hogan_assets.rb
+- lib/hogan_assets/engine.rb
+- lib/hogan_assets/hogan.rb
+- lib/hogan_assets/tilt.rb
+- lib/hogan_assets/version.rb
+- test/hogan_assets/tilt_test.rb
+- test/test_helper.rb
+- vendor/assets/javascripts/hogan.js
+homepage: ''
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.10
+signing_key: 
+specification_version: 3
+summary: Use compiled hogan.js (mustache) JavaScript templates with sprockets and
+  the Rails asset pipeline.
+test_files:
+- test/hogan_assets/tilt_test.rb
+- test/test_helper.rb