mustache-trimmer-rails 0.2.0

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2011 Joshua Peek
+
+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,17 @@
+Mustache Trimmer Rails
+======================
+
+ Josh Peek’s [Mustache Trimmer](https://github.com/josh/mustache-trimmer)
+ packaged for the Rails asset pipeline.
+
+Installation
+------------
+
+    gem install mustache-trimmer-rails
+
+License
+-------
+
+Copyright (c) 2012 Joshua Peek.
+
+Released under the MIT license. See `LICENSE` for details.

data/lib/mustache-trimmer-rails.rb

@@ -0,0 +1,27 @@
+require 'mustache/js'
+require 'sprockets'
+require 'tilt'
+
+module Sprockets
+  class MustacheJsTemplate < ::Tilt::Template
+    self.default_mime_type = 'application/javascript'
+    
+    def self.engine_initialized?
+      defined? ::Mustache.to_javascript
+    end
+
+    def initialize_engine
+      require_template_library 'mustache/js'
+    end
+
+    def prepare
+    end
+
+    def evaluate(scope, locals, &block)
+      Mustache.to_javascript(data)
+    end
+  end
+end
+
+Sprockets::Engines
+Sprockets.register_engine '.mustachejs', Sprockets::MustacheJsTemplate

data/lib/mustache/javascript_generator.rb

@@ -0,0 +1,331 @@
+require 'mustache'
+
+class Mustache
+  class JavascriptGenerator
+    def initialize
+      @n        = 0
+      @globals  = []
+      @locals   = []
+      @helpers  = {}
+      @partials = {}
+    end
+
+    def helpers
+      out = ""
+
+      if @helpers[:fetch]
+        global :fetch
+        out << <<-JS
+          fetch = function fetch(stack, key) {
+            var i, v;
+            for (i = stack.length - 1; i >= 0; i -= 1) {
+              v = stack[i][key];
+              if (v) {
+                return v;
+              }
+            }
+          };
+        JS
+      end
+
+      if @helpers[:escape]
+        global :escape
+        out << <<-JS
+          escape = function escape(value) {
+            return ('' + value)
+              .replace(/&/g, '&amp;')
+              .replace(/</g, '&lt;')
+              .replace(/>/g, '&gt;')
+              .replace(/\x22/g, '&quot;');
+          };
+        JS
+      end
+
+      if @helpers[:isEmpty]
+        @helpers[:isArray] = @helpers[:isObject] = true
+        global :isEmpty
+        out << <<-JS
+          isEmpty = function isEmpty(obj) {
+            var key;
+
+            if (!obj) {
+              return true;
+            } else if (isArray(obj)) {
+              return obj.length === 0;
+            } else if (isObject(obj)) {
+              for (key in obj) {
+                if (obj.hasOwnProperty(key)) {
+                  return false;
+                }
+              }
+              return true;
+            } else {
+              return false;
+            }
+          };
+        JS
+      end
+
+      if @helpers[:isArray]
+        global :isArray
+        out << <<-JS
+          isArray = Array.isArray || function (obj) {
+            return Object.prototype.toString.call(obj) === '[object Array]';
+          };
+        JS
+      end
+
+      if @helpers[:isObject]
+        global :isObject
+        out << <<-JS
+          isObject = function isObject(obj) {
+            return (obj && typeof obj === 'object');
+          };
+        JS
+      end
+
+      if @helpers[:isFunction]
+        global :isFunction
+        out << <<-JS
+          isFunction = function isFunction(obj) {
+            return !!(obj && obj.constructor && obj.call && obj.apply);
+          };
+        JS
+      end
+
+      if @helpers[:reduce]
+        global :reduce
+        out << <<-JS
+          reduce = Array.prototype.reduce || function (iterator, memo) {
+            var i;
+            for (i = 0; i < this.length; i++) {
+              memo = iterator(memo, this[i]);
+            }
+            return memo;
+          };
+        JS
+
+        global :traverse
+        out << <<-JS
+          traverse = function traverse(value, key) {
+            return value && value[key];
+          };
+        JS
+      end
+
+      out.gsub("          ", "")
+    end
+
+    def globals
+      if @globals.any?
+        "var #{@globals.join(', ')};\n"
+      else
+        ""
+      end
+    end
+
+    def locals
+      if @locals.last.any?
+        "var #{@locals.last.join(', ')};\n"
+      else
+        ""
+      end
+    end
+
+    def partials
+      @partials.values.join("\n")
+    end
+
+    def compile(exp)
+      main = global
+      body = global
+
+      compile_closure!(body, exp)
+
+      helpers = self.helpers
+
+      <<-JS.gsub("        ", "")
+        (function() {
+          #{globals.strip}
+          #{helpers.strip}
+          #{partials.strip}
+
+          #{main} = function #{main}(obj) {
+            var stack, out;
+            stack = [];
+            stack.push(obj);
+            out = [];
+            #{body}(stack, out);
+            return out.join("");
+          };
+
+          return #{main};
+        })()
+      JS
+    end
+
+    def compile!(exp)
+      case exp.first
+      when :multi
+        exp[1..-1].map { |e| compile!(e) }.join
+      when :static
+        str(exp[1])
+      when :mustache
+        send("on_#{exp[1]}", *exp[2..-1])
+      else
+        raise "Unhandled exp: #{exp.first}"
+      end
+    end
+
+    def on_section(name, content, raw, delims)
+      @helpers[:isEmpty] = true
+      @helpers[:isObject] = @helpers[:isArray] = @helpers[:isFunction] = true
+
+      f, v, i = global, local(:v), local(:i)
+
+      compile_closure!(f, content)
+
+      <<-JS
+        #{v} = #{compile!(name).strip};
+        if (!isEmpty(#{v})) {
+          if (isFunction(#{v})) {
+            out.push(#{v}.call(stack[stack.length - 1], function () {
+              var out = [];
+              #{f}(stack, out);
+              return out.join("");
+            }));
+          } else if (isArray(#{v})) {
+            for (#{i} = 0; #{i} < #{v}.length; #{i} += 1) {
+              stack.push(#{v}[#{i}]);
+              #{f}(stack, out);
+              stack.pop();
+            }
+          } else if (isObject(#{v})) {
+            stack.push(#{v});
+            #{f}(stack, out);
+            stack.pop();
+          } else {
+            #{f}(stack, out);
+          }
+        }
+      JS
+    end
+
+    def on_inverted_section(name, content, raw, _)
+      @helpers[:isEmpty] = true
+
+      f, v = global, local(:v)
+
+      compile_closure!(f, content)
+
+      <<-JS
+        #{v} = #{compile!(name).strip};
+        if (isEmpty(#{v})) {
+          #{f}(stack, out);
+        }
+      JS
+    end
+
+    def on_partial(name, indentation)
+      unless @partials[name]
+        @partials[name] = true # Stub for recursion
+
+        source   = Mustache.partial(name).to_s.gsub(/^/, indentation)
+        template = Mustache.templateify(source)
+
+        compile_closure!(name, template.tokens)
+      end
+
+      "#{name}(stack, out);\n"
+    end
+
+    def compile_closure!(name, tokens)
+      @locals.push([])
+      code = compile!(tokens)
+      locals = self.locals
+      @locals.pop
+
+      @partials[name] = <<-JS
+        #{name} = function #{name}(stack, out) {
+          #{locals.strip}
+          #{code.strip}
+        };
+      JS
+
+      nil
+    end
+
+    def on_utag(name)
+      @helpers[:isFunction] = true
+      @helpers[:isEmpty] = true
+
+      v = local(:v)
+
+      <<-JS
+        #{v} = #{compile!(name).strip};
+        if (isFunction(#{v})) {
+          #{v} = #{v}.call(stack[stack.length - 1]);
+        }
+        if (!isEmpty(#{v})) {
+          out.push(#{v});
+        }
+      JS
+    end
+
+    def on_etag(name)
+      @helpers[:isFunction] = true
+      @helpers[:isEmpty] = @helpers[:escape] = true
+
+      v = local(:v)
+
+      <<-JS
+        #{v} = #{compile!(name).strip};
+        if (isFunction(#{v})) {
+          #{v} = #{v}.call(stack[stack.length - 1]);
+        }
+        if (!isEmpty(#{v})) {
+          out.push(escape(#{v}));
+        }
+      JS
+    end
+
+    def on_fetch(names)
+      @helpers[:fetch] = true
+
+      names = names.map { |n| n.to_s }
+
+      case names.length
+      when 0
+        "stack[stack.length-1]"
+      when 1
+        "fetch(stack, #{names.first.inspect})"
+      else
+        @helpers[:reduce] = true
+        initial, *rest = names
+        "reduce.call(#{rest.inspect}, traverse, fetch(stack, #{initial.inspect}))"
+      end
+    end
+
+    def str(s)
+      "out.push(#{s.inspect});\n"
+    end
+
+    def global(name = nil)
+      if name
+        @globals << name.to_sym
+        name
+      else
+        @n += 1
+        name = :"g#{@n}"
+        @globals << name
+        name
+      end
+    end
+
+    def local(name = nil)
+      raise "not in closure" unless @locals.last
+      @locals.last << name.to_sym
+      name
+    end
+  end
+end

data/lib/mustache/js.rb

@@ -0,0 +1,9 @@
+require 'mustache'
+require 'mustache/javascript_generator'
+
+class Mustache
+  def self.to_javascript(source)
+    template = templateify(source)
+    JavascriptGenerator.new.compile(template.tokens)
+  end
+end

metadata

@@ -0,0 +1,86 @@
+--- !ruby/object:Gem::Specification
+name: mustache-trimmer-rails
+version: !ruby/object:Gem::Version
+  version: 0.2.0
+  prerelease: 
+platform: ruby
+authors:
+- Joshua Peek
+- Hugh Evans
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-10-09 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: mustache
+  requirement: &70218250760820 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.99.4
+  type: :runtime
+  prerelease: false
+  version_requirements: *70218250760820
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: &70218250760400 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70218250760400
+- !ruby/object:Gem::Dependency
+  name: therubyracer
+  requirement: &70218250759900 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70218250759900
+description: ! '    Ruby lib that compiles Mustache templates into pure Javascript
+
+'
+email: josh@joshpeek.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/mustache/javascript_generator.rb
+- lib/mustache/js.rb
+- lib/mustache-trimmer-rails.rb
+- LICENSE
+- README.md
+homepage: https://github.com/icelab/mustache-trimmer-rails
+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: mustache-trimmer-rails
+rubygems_version: 1.8.11
+signing_key: 
+specification_version: 3
+summary: Mustache JS compiler packaged for the Rails asset Pipeline
+test_files: []
+has_rdoc: