nulogy-poirot 0.2.4.1

data/.gitignore

@@ -0,0 +1,3 @@
+pkg/*
+*.gem
+.bundle

data/Gemfile

@@ -0,0 +1,6 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in poirot.gemspec
+gemspec
+gem 'rails', '>=3.0.0'
+gem 'mustache'

data/Gemfile.lock

@@ -0,0 +1,83 @@
+PATH
+  remote: .
+  specs:
+    nulogy-poirot (0.2.4.1)
+      mustache
+      railties (> 3)
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    abstract (1.0.0)
+    actionmailer (3.0.9)
+      actionpack (= 3.0.9)
+      mail (~> 2.2.19)
+    actionpack (3.0.9)
+      activemodel (= 3.0.9)
+      activesupport (= 3.0.9)
+      builder (~> 2.1.2)
+      erubis (~> 2.6.6)
+      i18n (~> 0.5.0)
+      rack (~> 1.2.1)
+      rack-mount (~> 0.6.14)
+      rack-test (~> 0.5.7)
+      tzinfo (~> 0.3.23)
+    activemodel (3.0.9)
+      activesupport (= 3.0.9)
+      builder (~> 2.1.2)
+      i18n (~> 0.5.0)
+    activerecord (3.0.9)
+      activemodel (= 3.0.9)
+      activesupport (= 3.0.9)
+      arel (~> 2.0.10)
+      tzinfo (~> 0.3.23)
+    activeresource (3.0.9)
+      activemodel (= 3.0.9)
+      activesupport (= 3.0.9)
+    activesupport (3.0.9)
+    arel (2.0.10)
+    builder (2.1.2)
+    erubis (2.6.6)
+      abstract (>= 1.0.0)
+    i18n (0.5.0)
+    mail (2.2.19)
+      activesupport (>= 2.3.6)
+      i18n (>= 0.4.0)
+      mime-types (~> 1.16)
+      treetop (~> 1.4.8)
+    mime-types (1.16)
+    mustache (0.99.4)
+    polyglot (0.3.1)
+    rack (1.2.3)
+    rack-mount (0.6.14)
+      rack (>= 1.0.0)
+    rack-test (0.5.7)
+      rack (>= 1.0)
+    rails (3.0.9)
+      actionmailer (= 3.0.9)
+      actionpack (= 3.0.9)
+      activerecord (= 3.0.9)
+      activeresource (= 3.0.9)
+      activesupport (= 3.0.9)
+      bundler (~> 1.0)
+      railties (= 3.0.9)
+    railties (3.0.9)
+      actionpack (= 3.0.9)
+      activesupport (= 3.0.9)
+      rake (>= 0.8.7)
+      rdoc (~> 3.4)
+      thor (~> 0.14.4)
+    rake (0.9.2)
+    rdoc (3.8)
+    thor (0.14.6)
+    treetop (1.4.9)
+      polyglot (>= 0.3.1)
+    tzinfo (0.3.29)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  mustache
+  nulogy-poirot!
+  rails (>= 3.0.0)

data/Rakefile

@@ -0,0 +1,2 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks

data/Readme.markdown

@@ -0,0 +1,84 @@
+# Poirot
+
+## Description
+
+Allows you to use [Mustache](http://mustache.github.com/) template partials in Rails, also
+ads a helper method to easily allow JavaScript to re-use the same templates.
+
+## Usage
+
+Create a partial just like you would with erb, prefixing the name with an underscore.
+
+    app/views/posts/_post_list.html.mustache
+
+The template will have access to all normal rails helper methods and any instance variables
+that were set in the controller.  If you need more than this an optional view class can be
+included, it should have the same name as the partial, but without the underscore.
+
+    app/views/posts/post_list_view.rb
+    
+    module Posts
+      class PostListView < Poirot::View
+        def foo
+          "bar"
+        end
+    
+        def post_link
+          post_path(post)
+        end
+      end
+    end
+
+The view class has access to all the normal Rails helpers and access to the controller
+instance variables, e.g @post becomes the method post.
+
+Also included is a simple view helper for including mustache templates in a page ready for
+use by JavaScript.
+
+    <%= template_include_tag 'post_list' %>
+
+The above will insert a script tag with the contents of the partial called `post_list`, the 
+type will be set as `text/mustache` and the id will be `post-list-template`.
+
+    <script id="post-list-template" type="text/mustache">
+      <!-- template will be here! -->
+    </script>
+
+### Javascript Helper
+
+Poirot also adds a javascript helper for using mustache templates from the browser.  In Rails 3.1 this will be automatically added to the asset pipeline, you just need to add `//= require poirot` in your application.js file.
+
+If you are using rails 3 then you can run the `rails g poirot:install` to install the javascripts in your application.
+
+Using the poirot javascript helper is simple, given a template added to the page using `template_include_tag`
+
+    <%= template_include_tag 'post_list' %>
+
+You can render this template from javascript by doing the following
+
+    poirot.postList()
+
+This will return the contents of the `post_list` template wrapped in a jQuery object, ready for inserting into the dom.  If you have data to pass to the template then you can pass it as the argument to the function, e.g.
+
+    poirot.postList({foo: "bar"})
+
+#### Using Handlebars.js
+
+It is possible to use handlebars instead of mustache when rendering templates client side.  To do this you need to first include the handlebars.js source.  The instead of including `//= require poirot` in the asset pipeline you should include `//= require poirot-handlebars`
+
+#### Using Hogan.js
+
+It is also possible to use hogan.js instead of mustache when rendering templates client side.  To do this you need to first include the hogan.js source.  The instead of including `//= require poirot` in the asset pipeline you should include `//= require poirot-hogan`
+
+## Dependencies
+
+*  Rails >3.0.0
+*  Mustache
+
+## More
+
+An [example](http://github.com/olivernn/notepad) app using Poirot
+
+## Credits
+
+[Mark Evans](http://github.com/markevans) & [Oliver Nightingale](http://github.com/olivernn)

data/lib/generators/poirot/install/install_generator.rb

@@ -0,0 +1,31 @@
+require 'rails'
+
+module Poirot
+  module Generators
+    class InstallGenerator < ::Rails::Generators::Base
+
+      desc "This generator installs Poirot JavaScript helper"
+      source_root File.expand_path('../../../../../vendor/assets/javascripts', __FILE__)
+
+      def copy_mustache
+        say_status("copying", "Mustache.js", :green)
+        copy_file "poirot-mustache/mustache.js", "public/javascripts/mustache.js"
+      end
+
+      def copy_poirot
+        say_status("copying", "poirot.js", :green)
+        copy_file "poirot-base/poirot.js", "public/javascripts/poirot.js"
+      end
+
+      def copy_poirot_handlebars
+        say_status("copying", "poirot-handlebars.js", :green)
+        copy_file "poirot-handlebars/poirot-handlebars.js", "public/javascripts/poirot-handlebars.js"
+      end
+
+      def copy_poirot_hogan
+        say_status("copying", "poirot-hogan.js", :green)
+        copy_file "poirot-hogan/poirot-hogan.js", "public/javascripts/poirot-hogan.js"
+      end
+    end
+  end
+end if ::Rails.version < "3.1"

data/lib/poirot.rb

@@ -0,0 +1,17 @@
+require 'mustache'
+require 'poirot/handler'
+require 'poirot/view_helper'
+require 'poirot/view'
+require 'poirot/asset_helper'
+
+ActionView::Template.register_template_handler(:mustache, Poirot::Handler)
+ActionView::Base.send :include, Poirot::AssetHelper
+
+module Poirot
+  class Engine < Rails::Engine ; end if Rails.version >= "3.1"
+  class Railtie < Rails::Railtie
+    config.before_configuration do |app|
+      app.config.autoload_paths += %W(#{app.config.root}/app/views)
+    end
+  end
+end

data/lib/poirot/asset_helper.rb

@@ -0,0 +1,35 @@
+module Poirot
+  module AssetHelper
+    def template_include_tag(*sources)
+      sources.collect do |source|
+        template = File.open(resolve_partial_path(source), "rb")
+        content_tag :script, template.read.html_safe, :type => "text/mustache", :id => "#{template_name(source).parameterize.dasherize}-template"
+      end.join("\n").html_safe
+    end
+
+    private
+
+    def is_absolute_path?(source)
+      source.to_s =~ /^\//
+    end
+
+    def template_name(source)
+      if is_absolute_path?(source)
+        source.to_s.split('/').last
+      else
+        source
+      end
+    end
+
+    def resolve_partial_path(source)
+      if is_absolute_path?(source)
+        segments = source.to_s.split('/')
+        partial_name = "_#{segments.pop}.html.mustache"
+        segments << partial_name
+        Rails.root.join('app/views', *segments)
+      else
+        Rails.root.join('app/views', controller_name, "_#{source}.html.mustache")
+      end
+    end
+  end
+end

data/lib/poirot/handler.rb

@@ -0,0 +1,15 @@
+module Poirot
+  class Handler
+    def self.call(template)
+      view_path = "#{template.virtual_path}_view"
+      abs_view_path = Rails.root.join('app/views', view_path)
+      view_class = begin
+        view_path.classify.constantize
+      rescue NameError => e
+        Rails.logger.info ">>> #{e}"
+        Poirot::View
+      end
+      "#{view_class}.new(self, '#{template.source.gsub(/'/, "\\\\'")}').render.html_safe"
+    end
+  end
+end

data/lib/poirot/version.rb

@@ -0,0 +1,3 @@
+module Poirot
+  VERSION = "0.2.4.1"
+end

data/lib/poirot/view.rb

@@ -0,0 +1,76 @@
+module Poirot
+  class View < Mustache
+
+    include Poirot::ViewHelper
+
+    def initialize(view_context, template_source)
+      @view_context = view_context
+      @params = view_context.params || {}
+      self.template = template_source
+      assign_variables!
+    end
+
+    self.template_extension = 'html.mustache'
+
+    def self.inherited(view_class)
+      self.template_path = Rails.root.join('app', 'views', view_class.name.split('::').first.downcase)
+    end
+
+    def respond_to?(method_sym, include_private = false)
+      if view_context.respond_to?(method_sym)
+        true
+      else
+        super
+      end
+    end
+
+    def render_buffer(buffer)
+      self.render(buffer, context).html_safe
+    end
+
+    def include_partial(name)
+      path = ["app/views", controller_name]
+      path += name.split("/")
+      path.delete(nil)
+      path.last.replace("_#{path.last}.html.mustache")
+
+      filename = path.join("/")
+
+      Dir.chdir(Rails.root) do
+        render_buffer(File.read(filename))
+      end
+    end
+
+    def method_missing(method_name, *args, &block)
+      if instance_variable_names.include?("@#{method_name}") && args.empty?
+        instance_variable_get("@#{method_name}")
+      else
+        view_context.send(method_name,*args, &block)
+      end
+    end
+
+    private
+
+    attr_reader :view_context
+    attr_reader :params
+
+    def assign_variables!
+      variables = view_context.instance_variable_names.select{|name| name =~ /^@[^_]/}
+      variables.each do |name|
+        instance_var = view_context.instance_variable_get(name)
+        instance_variable_set(name, instance_var)
+        self[name.tr('@','').to_sym] = instance_var
+      end
+
+      if Rails.version >= "3.1"
+        # get the locals from the view context, is there a better way?
+        locals = view_context.send(:view_renderer).send(:_partial_renderer).instance_variable_get("@locals") || {}
+
+        locals.each do |name, val|
+          instance_variable_set("@#{name}", val)
+          self[name] = val
+        end
+      end
+    end
+  end
+end

data/lib/poirot/view_helper.rb

@@ -0,0 +1,7 @@
+module Poirot
+  module ViewHelper
+    def csrf_token
+      tag(:input, :name => 'authenticity_token', :type => 'hidden', :value => form_authenticity_token)
+    end
+  end
+end

data/poirot.gemspec

@@ -0,0 +1,24 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "poirot/version"
+
+Gem::Specification.new do |s|
+  s.name        = "nulogy-poirot"
+  s.version     = Poirot::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Oliver Nightingale", "Mark Evans"]
+  s.email       = ["oliver.nightingale1@gmail.com"]
+  s.homepage    = "http://rubygems.org/gems/poirot"
+  s.summary     = %q{mustache support for rails}
+  s.description = %q{mustaches are cool}
+
+  s.add_dependency('railties', '>3')
+  s.add_dependency('mustache')
+
+  s.rubyforge_project = "poirot"
+
+  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/vendor/assets/javascripts/poirot-base/index.js

@@ -0,0 +1 @@
+//= require ./poirot

data/vendor/assets/javascripts/poirot-base/poirot.js

@@ -0,0 +1,28 @@
+var poirot = (function ($) {
+
+  var viewFactory = function (template, partials) {
+    return function (data) {
+      return $(Mustache.to_html(template, data, partials))
+    }
+  }
+
+  var poirot = {
+    _partials: {},
+    _viewFactory: viewFactory
+  }
+
+  $(document).ready(function () {
+    $('script[type="text/mustache"]').each(function () {
+      var template = $(this).html()
+      var methodName = this.id.replace(/-([a-z])/g, function (str) {
+        return str.replace("-", "").toUpperCase()
+      }).replace("Template", "")
+
+      poirot._partials[methodName] = template
+
+      poirot[methodName] = poirot._viewFactory(template, poirot._partials)
+    })
+  })
+
+  return poirot
+})(jQuery)

data/vendor/assets/javascripts/poirot-handlebars/index.js

@@ -0,0 +1,2 @@
+//= require poirot-base
+//= require ./poirot-handlebars

data/vendor/assets/javascripts/poirot-handlebars/poirot-handlebars.js

@@ -0,0 +1,8 @@
+;(function () {
+  poirot._viewFactory = function (template, partials) {
+    var compiledTemplate = Handlebars.compile(template)
+    return function (data) {
+      return $(compiledTemplate(data))
+    }
+  }
+})()

data/vendor/assets/javascripts/poirot-hogan/index.js

@@ -0,0 +1,2 @@
+//= require poirot-base
+//= require ./poirot-hogan

data/vendor/assets/javascripts/poirot-hogan/poirot-hogan.js

@@ -0,0 +1,8 @@
+;(function () {
+  poirot._viewFactory = function (template, partials) {
+    var compiledTemplate = Hogan.compile(template)
+    return function (data) {
+      return $(compiledTemplate.render(data, partials))
+    }
+  }
+})()

data/vendor/assets/javascripts/poirot-mustache/index.js

@@ -0,0 +1 @@
+//= require ./mustache

data/vendor/assets/javascripts/poirot-mustache/mustache.js

@@ -0,0 +1,536 @@
+/*!
+ * mustache.js - Logic-less {{mustache}} templates with JavaScript
+ * http://github.com/janl/mustache.js
+ */
+var Mustache = (typeof module !== "undefined" && module.exports) || {};
+
+(function (exports) {
+
+  exports.name = "mustache.js";
+  exports.version = "0.5.0-dev";
+  exports.tags = ["{{", "}}"];
+  exports.parse = parse;
+  exports.compile = compile;
+  exports.render = render;
+  exports.clearCache = clearCache;
+
+  // This is here for backwards compatibility with 0.4.x.
+  exports.to_html = function (template, view, partials, send) {
+    var result = render(template, view, partials);
+
+    if (typeof send === "function") {
+      send(result);
+    } else {
+      return result;
+    }
+  };
+
+  var _toString = Object.prototype.toString;
+  var _isArray = Array.isArray;
+  var _forEach = Array.prototype.forEach;
+  var _trim = String.prototype.trim;
+
+  var isArray;
+  if (_isArray) {
+    isArray = _isArray;
+  } else {
+    isArray = function (obj) {
+      return _toString.call(obj) === "[object Array]";
+    };
+  }
+
+  var forEach;
+  if (_forEach) {
+    forEach = function (obj, callback, scope) {
+      return _forEach.call(obj, callback, scope);
+    };
+  } else {
+    forEach = function (obj, callback, scope) {
+      for (var i = 0, len = obj.length; i < len; ++i) {
+        callback.call(scope, obj[i], i, obj);
+      }
+    };
+  }
+
+  var spaceRe = /^\s*$/;
+
+  function isWhitespace(string) {
+    return spaceRe.test(string);
+  }
+
+  var trim;
+  if (_trim) {
+    trim = function (string) {
+      return string == null ? "" : _trim.call(string);
+    };
+  } else {
+    var trimLeft, trimRight;
+
+    if (isWhitespace("\xA0")) {
+      trimLeft = /^\s+/;
+      trimRight = /\s+$/;
+    } else {
+      // IE doesn't match non-breaking spaces with \s, thanks jQuery.
+      trimLeft = /^[\s\xA0]+/;
+      trimRight = /[\s\xA0]+$/;
+    }
+
+    trim = function (string) {
+      return string == null ? "" :
+        String(string).replace(trimLeft, "").replace(trimRight, "");
+    };
+  }
+
+  var escapeMap = {
+    "&": "&amp;",
+    "<": "&lt;",
+    ">": "&gt;",
+    '"': '&quot;',
+    "'": '&#39;'
+  };
+
+  function escapeHTML(string) {
+    return String(string).replace(/&(?!\w+;)|[<>"']/g, function (s) {
+      return escapeMap[s] || s;
+    });
+  }
+
+  /**
+   * Adds the `template`, `line`, and `file` properties to the given error
+   * object and alters the message to provide more useful debugging information.
+   */
+  function debug(e, template, line, file) {
+    file = file || "<template>";
+
+    var lines = template.split("\n"),
+        start = Math.max(line - 3, 0),
+        end = Math.min(lines.length, line + 3),
+        context = lines.slice(start, end);
+
+    var c;
+    for (var i = 0, len = context.length; i < len; ++i) {
+      c = i + start + 1;
+      context[i] = (c === line ? " >> " : "    ") + context[i];
+    }
+
+    e.template = template;
+    e.line = line;
+    e.file = file;
+    e.message = [file + ":" + line, context.join("\n"), "", e.message].join("\n");
+
+    return e;
+  }
+
+  /**
+   * Looks up the value of the given `name` in the given context `stack`.
+   */
+  function lookup(name, stack, defaultValue) {
+    if (name === ".") {
+      return stack[stack.length - 1];
+    }
+
+    var names = name.split(".");
+    var lastIndex = names.length - 1;
+    var target = names[lastIndex];
+
+    var value, context, i = stack.length, j, localStack;
+    while (i) {
+      localStack = stack.slice(0);
+      context = stack[--i];
+
+      j = 0;
+      while (j < lastIndex) {
+        context = context[names[j++]];
+
+        if (context == null) {
+          break;
+        }
+
+        localStack.push(context);
+      }
+
+      if (context && typeof context === "object" && target in context) {
+        value = context[target];
+        break;
+      }
+    }
+
+    // If the value is a function, call it in the current context.
+    if (typeof value === "function") {
+      value = value.call(localStack[localStack.length - 1]);
+    }
+
+    if (value == null)  {
+      return defaultValue;
+    }
+
+    return value;
+  }
+
+  function renderSection(name, stack, callback, inverted) {
+    var buffer = "";
+    var value =  lookup(name, stack);
+
+    if (inverted) {
+      // From the spec: inverted sections may render text once based on the
+      // inverse value of the key. That is, they will be rendered if the key
+      // doesn't exist, is false, or is an empty list.
+      if (value == null || value === false || (isArray(value) && value.length === 0)) {
+        buffer += callback();
+      }
+    } else if (isArray(value)) {
+      forEach(value, function (value) {
+        stack.push(value);
+        buffer += callback();
+        stack.pop();
+      });
+    } else if (typeof value === "object") {
+      stack.push(value);
+      buffer += callback();
+      stack.pop();
+    } else if (typeof value === "function") {
+      var scope = stack[stack.length - 1];
+      var scopedRender = function (template) {
+        return render(template, scope);
+      };
+      buffer += value.call(scope, callback(), scopedRender) || "";
+    } else if (value) {
+      buffer += callback();
+    }
+
+    return buffer;
+  }
+
+  /**
+   * Parses the given `template` and returns the source of a function that,
+   * with the proper arguments, will render the template. Recognized options
+   * include the following:
+   *
+   *   - file     The name of the file the template comes from (displayed in
+   *              error messages)
+   *   - tags     An array of open and close tags the `template` uses. Defaults
+   *              to the value of Mustache.tags
+   *   - debug    Set `true` to log the body of the generated function to the
+   *              console
+   *   - space    Set `true` to preserve whitespace from lines that otherwise
+   *              contain only a {{tag}}. Defaults to `false`
+   */
+  function parse(template, options) {
+    options = options || {};
+
+    var tags = options.tags || exports.tags,
+        openTag = tags[0],
+        closeTag = tags[tags.length - 1];
+
+    var code = [
+      'var buffer = "";', // output buffer
+      "\nvar line = 1;", // keep track of source line number
+      "\ntry {",
+      '\nbuffer += "'
+    ];
+
+    var spaces = [],      // indices of whitespace in code on the current line
+        hasTag = false,   // is there a {{tag}} on the current line?
+        nonSpace = false; // is there a non-space char on the current line?
+
+    // Strips all space characters from the code array for the current line
+    // if there was a {{tag}} on it and otherwise only spaces.
+    var stripSpace = function () {
+      if (hasTag && !nonSpace && !options.space) {
+        while (spaces.length) {
+          code.splice(spaces.pop(), 1);
+        }
+      } else {
+        spaces = [];
+      }
+
+      hasTag = false;
+      nonSpace = false;
+    };
+
+    var sectionStack = [], updateLine, nextOpenTag, nextCloseTag;
+
+    var setTags = function (source) {
+      tags = trim(source).split(/\s+/);
+      nextOpenTag = tags[0];
+      nextCloseTag = tags[tags.length - 1];
+    };
+
+    var includePartial = function (source) {
+      code.push(
+        '";',
+        updateLine,
+        '\nvar partial = partials["' + trim(source) + '"];',
+        '\nif (partial) {',
+        '\n  buffer += render(partial,stack[stack.length - 1],partials);',
+        '\n}',
+        '\nbuffer += "'
+      );
+    };
+
+    var openSection = function (source, inverted) {
+      var name = trim(source);
+
+      if (name === "") {
+        throw debug(new Error("Section name may not be empty"), template, line, options.file);
+      }
+
+      sectionStack.push({name: name, inverted: inverted});
+
+      code.push(
+        '";',
+        updateLine,
+        '\nvar name = "' + name + '";',
+        '\nvar callback = (function () {',
+        '\n  return function () {',
+        '\n    var buffer = "";',
+        '\nbuffer += "'
+      );
+    };
+
+    var openInvertedSection = function (source) {
+      openSection(source, true);
+    };
+
+    var closeSection = function (source) {
+      var name = trim(source);
+      var openName = sectionStack.length != 0 && sectionStack[sectionStack.length - 1].name;
+
+      if (!openName || name != openName) {
+        throw debug(new Error('Section named "' + name + '" was never opened'), template, line, options.file);
+      }
+
+      var section = sectionStack.pop();
+
+      code.push(
+        '";',
+        '\n    return buffer;',
+        '\n  };',
+        '\n})();'
+      );
+
+      if (section.inverted) {
+        code.push("\nbuffer += renderSection(name,stack,callback,true);");
+      } else {
+        code.push("\nbuffer += renderSection(name,stack,callback);");
+      }
+
+      code.push('\nbuffer += "');
+    };
+
+    var sendPlain = function (source) {
+      code.push(
+        '";',
+        updateLine,
+        '\nbuffer += lookup("' + trim(source) + '",stack,"");',
+        '\nbuffer += "'
+      );
+    };
+
+    var sendEscaped = function (source) {
+      code.push(
+        '";',
+        updateLine,
+        '\nbuffer += escapeHTML(lookup("' + trim(source) + '",stack,""));',
+        '\nbuffer += "'
+      );
+    };
+
+    var line = 1, c, callback;
+    for (var i = 0, len = template.length; i < len; ++i) {
+      if (template.slice(i, i + openTag.length) === openTag) {
+        i += openTag.length;
+        c = template.substr(i, 1);
+        updateLine = '\nline = ' + line + ';';
+        nextOpenTag = openTag;
+        nextCloseTag = closeTag;
+        hasTag = true;
+
+        switch (c) {
+        case "!": // comment
+          i++;
+          callback = null;
+          break;
+        case "=": // change open/close tags, e.g. {{=<% %>=}}
+          i++;
+          closeTag = "=" + closeTag;
+          callback = setTags;
+          break;
+        case ">": // include partial
+          i++;
+          callback = includePartial;
+          break;
+        case "#": // start section
+          i++;
+          callback = openSection;
+          break;
+        case "^": // start inverted section
+          i++;
+          callback = openInvertedSection;
+          break;
+        case "/": // end section
+          i++;
+          callback = closeSection;
+          break;
+        case "{": // plain variable
+          closeTag = "}" + closeTag;
+          // fall through
+        case "&": // plain variable
+          i++;
+          nonSpace = true;
+          callback = sendPlain;
+          break;
+        default: // escaped variable
+          nonSpace = true;
+          callback = sendEscaped;
+        }
+
+        var end = template.indexOf(closeTag, i);
+
+        if (end === -1) {
+          throw debug(new Error('Tag "' + openTag + '" was not closed properly'), template, line, options.file);
+        }
+
+        var source = template.substring(i, end);
+
+        if (callback) {
+          callback(source);
+        }
+
+        // Maintain line count for \n in source.
+        var n = 0;
+        while (~(n = source.indexOf("\n", n))) {
+          line++;
+          n++;
+        }
+
+        i = end + closeTag.length - 1;
+        openTag = nextOpenTag;
+        closeTag = nextCloseTag;
+      } else {
+        c = template.substr(i, 1);
+
+        switch (c) {
+        case '"':
+        case "\\":
+          nonSpace = true;
+          code.push("\\" + c);
+          break;
+        case "\r":
+          // Ignore carriage returns.
+          break;
+        case "\n":
+          spaces.push(code.length);
+          code.push("\\n");
+          stripSpace(); // Check for whitespace on the current line.
+          line++;
+          break;
+        default:
+          if (isWhitespace(c)) {
+            spaces.push(code.length);
+          } else {
+            nonSpace = true;
+          }
+
+          code.push(c);
+        }
+      }
+    }
+
+    if (sectionStack.length != 0) {
+      throw debug(new Error('Section "' + sectionStack[sectionStack.length - 1].name + '" was not closed properly'), template, line, options.file);
+    }
+
+    // Clean up any whitespace from a closing {{tag}} that was at the end
+    // of the template without a trailing \n.
+    stripSpace();
+
+    code.push(
+      '";',
+      "\nreturn buffer;",
+      "\n} catch (e) { throw {error: e, line: line}; }"
+    );
+
+    // Ignore `buffer += "";` statements.
+    var body = code.join("").replace(/buffer \+= "";\n/g, "");
+
+    if (options.debug) {
+      if (typeof console != "undefined" && console.log) {
+        console.log(body);
+      } else if (typeof print === "function") {
+        print(body);
+      }
+    }
+
+    return body;
+  }
+
+  /**
+   * Used by `compile` to generate a reusable function for the given `template`.
+   */
+  function _compile(template, options) {
+    var args = "view,partials,stack,lookup,escapeHTML,renderSection,render";
+    var body = parse(template, options);
+    var fn = new Function(args, body);
+
+    // This anonymous function wraps the generated function so we can do
+    // argument coercion, setup some variables, and handle any errors
+    // encountered while executing it.
+    return function (view, partials) {
+      partials = partials || {};
+
+      var stack = [view]; // context stack
+
+      try {
+        return fn(view, partials, stack, lookup, escapeHTML, renderSection, render);
+      } catch (e) {
+        throw debug(e.error, template, e.line, options.file);
+      }
+    };
+  }
+
+  // Cache of pre-compiled templates.
+  var _cache = {};
+
+  /**
+   * Clear the cache of compiled templates.
+   */
+  function clearCache() {
+    _cache = {};
+  }
+
+  /**
+   * Compiles the given `template` into a reusable function using the given
+   * `options`. In addition to the options accepted by Mustache.parse,
+   * recognized options include the following:
+   *
+   *   - cache    Set `false` to bypass any pre-compiled version of the given
+   *              template. Otherwise, a given `template` string will be cached
+   *              the first time it is parsed
+   */
+  function compile(template, options) {
+    options = options || {};
+
+    // Use a pre-compiled version from the cache if we have one.
+    if (options.cache !== false) {
+      if (!_cache[template]) {
+        _cache[template] = _compile(template, options);
+      }
+
+      return _cache[template];
+    }
+
+    return _compile(template, options);
+  }
+
+  /**
+   * High-level function that renders the given `template` using the given
+   * `view` and `partials`. If you need to use any of the template options (see
+   * `compile` above), you must compile in a separate step, and then call that
+   * compiled function.
+   */
+  function render(template, view, partials) {
+    return compile(template)(view, partials);
+  }
+
+})(Mustache);

data/vendor/assets/javascripts/poirot/index.js

@@ -0,0 +1,2 @@
+//= require poirot-base
+//= require poirot-mustache

metadata

@@ -0,0 +1,106 @@
+--- !ruby/object:Gem::Specification
+name: nulogy-poirot
+version: !ruby/object:Gem::Version
+  version: 0.2.4.1
+  prerelease: 
+platform: ruby
+authors:
+- Oliver Nightingale
+- Mark Evans
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-10-01 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: railties
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>'
+      - !ruby/object:Gem::Version
+        version: '3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>'
+      - !ruby/object:Gem::Version
+        version: '3'
+- !ruby/object:Gem::Dependency
+  name: mustache
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: mustaches are cool
+email:
+- oliver.nightingale1@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- Gemfile.lock
+- Rakefile
+- Readme.markdown
+- lib/generators/poirot/install/install_generator.rb
+- lib/poirot.rb
+- lib/poirot/asset_helper.rb
+- lib/poirot/handler.rb
+- lib/poirot/version.rb
+- lib/poirot/view.rb
+- lib/poirot/view_helper.rb
+- poirot.gemspec
+- vendor/assets/javascripts/poirot-base/index.js
+- vendor/assets/javascripts/poirot-base/poirot.js
+- vendor/assets/javascripts/poirot-handlebars/index.js
+- vendor/assets/javascripts/poirot-handlebars/poirot-handlebars.js
+- vendor/assets/javascripts/poirot-hogan/index.js
+- vendor/assets/javascripts/poirot-hogan/poirot-hogan.js
+- vendor/assets/javascripts/poirot-mustache/index.js
+- vendor/assets/javascripts/poirot-mustache/mustache.js
+- vendor/assets/javascripts/poirot/index.js
+homepage: http://rubygems.org/gems/poirot
+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'
+      segments:
+      - 0
+      hash: 2462592963835808659
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: 2462592963835808659
+requirements: []
+rubyforge_project: poirot
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: mustache support for rails
+test_files: []