herman-haml-sprockets 0.0.8

data/.gitignore

@@ -0,0 +1,7 @@
+*swp
+*~
+*bak
+*.gem
+.bundle
+Gemfile.lock
+pkg/*

data/Gemfile

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

data/LICENSE

@@ -0,0 +1,8 @@
+Copyright (c) 2011 Vagmi Mudumbai
+
+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,33 @@
+# Using HAML-JS with Sprockets and Rails 3.1
+
+## About
+
+Rails 3.1 uses sprockets for its asset pipeline. Rails 3.1 has shown considerable love for SCSS and SASS but has left [HAML] out. We at [Dharana Software Innovations][] are die hard HAML fans. We beleive that it is the best templating language around. So we would like to have it as a part of our client side toolkit as well. The [haml-js] project does exactly that. It was written for Node.js but works well with the browser too.
+
+## How to use it?
+
+The gem includes [haml-js]. You would not have to download it separately. To use this gem, you need to do the following. 
+
+In the `Gemfile`, add the following line.
+
+    gem "haml-sprockets"
+
+Now, you can create hamljs files under `app/assets/javascripts/templates` folder. You can create the templates folder, if it does not already exist.
+
+    // code for app/assets/javascripts/templates/hello.jst.hamljs
+    %h1 Hello HAML
+
+You can now access the template anywhere in your javascript or coffeescript code.
+
+    JST["templates/hello"]()
+
+This should give you back the string `"<h1>Hello HAML</h1>"`.
+
+## LICENSE
+
+This is distributed under the MIT license.
+
+
+[HAML]: http://haml-lang.com/
+[haml-js]: https://github.com/creationix/haml-js
+[Dharana Software Innovations]: http://www.dharanasoft.com/

data/Rakefile

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

data/haml-sprockets.gemspec

@@ -0,0 +1,28 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "haml-sprockets/version"
+
+Gem::Specification.new do |s|
+  s.name        = "herman-haml-sprockets"
+  s.version     = Haml::Sprockets::VERSION
+  s.authors     = ["vagmi", 'Herman Moreno']
+  s.email       = ["vagmi.mudumbai@gmail.com", 'herman.moreno@crowdint.com']
+  s.homepage    = "https://github.com/supherman/haml-sprockets"
+  s.summary     = %q{Use the awesome haml-js javascript templating lib in Ruby}
+  s.description = %q{Use the JST processor and have haml code read in and appended to application.js}
+
+  s.rubyforge_project = "herman-haml-sprockets"
+
+  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"]
+
+  # specify any dependencies here; for example:
+  # s.add_development_dependency "rspec"
+  s.add_runtime_dependency "tilt", "~> 1.3"
+  s.add_runtime_dependency "sprockets", "~> 2.0"
+  s.add_runtime_dependency "execjs", "~> 1.3.0"
+
+  s.add_development_dependency 'rspec'
+end

data/lib/haml-sprockets.rb

@@ -0,0 +1,34 @@
+require 'haml-sprockets/version'
+require 'tilt'
+require 'sprockets'
+require 'execjs'
+
+module Haml
+  module Sprockets
+    class Template < ::Tilt::Template
+      def self.engine_initialized?
+        true
+      end
+
+      def initialize_engine
+      end
+
+      def prepare
+      end
+
+      def evaluate(scope, locals, &block)
+        haml_code = data.dup
+        haml_code = haml_code.gsub(/\\/,"\\\\").gsub(/\'/,"\\\\'").gsub(/\n/,"\\n")
+
+        haml_path = File.expand_path("../../vendor/assets/javascripts/haml.js", __FILE__)
+        haml_lib = File.read(haml_path)
+        context = ExecJS.compile(haml_lib)
+        return context.eval("Haml.optimize(Haml.compile('#{haml_code}', {escapeHtmlByDefault: true}))")
+      end
+    end
+  end
+end
+
+Sprockets::Engines
+Sprockets.register_engine '.hamljs', Haml::Sprockets::Template
+require 'haml-sprockets/engine' if defined?(Rails)

data/lib/haml-sprockets/engine.rb

@@ -0,0 +1,7 @@
+module Haml
+  module Sprockets
+    class Engine < ::Rails::Engine
+      # just to get the vendor directories included into assets
+    end
+  end
+end

data/lib/haml-sprockets/version.rb

@@ -0,0 +1,5 @@
+module Haml
+  module Sprockets
+    VERSION = "0.0.8"
+  end
+end

data/spec/lib/haml-sprockets_spec.rb

@@ -0,0 +1,43 @@
+require 'spec_helper'
+
+describe Haml::Sprockets::Template do
+  describe 'evaluate' do
+    def process(data)
+      described_class.new { data }.render
+    end
+
+    describe 'string escaping' do
+      before do
+        Rails = double('Rails', :root => '/some/dir')
+        File.stub(:read)
+        @context = double('context')
+        ExecJS.stub(:compile).and_return(@context)
+      end
+
+      it 'should leave clean string alone' do
+        @context.should_receive(:eval).with(/'test'/)
+        process(%{test})
+      end
+
+      it 'should leave double quotes alone' do
+        @context.should_receive(:eval).with(/'test "test"'/)
+        process(%{test "test"})
+      end
+
+      it 'should double escape characters' do
+        @context.should_receive(:eval).with(/'test\\ntest'/)
+        process(%{test\ntest})
+      end
+
+      it 'should double escape single quotes' do
+        @context.should_receive(:eval).with(/'test \\'test\\''/)
+        process(%{test 'test'})
+      end
+
+      after do
+        Object.send(:remove_const, 'Rails')
+      end
+    end
+  end
+end
+

data/spec/spec_helper.rb

@@ -0,0 +1,2 @@
+require 'haml-sprockets'
+

data/vendor/assets/javascripts/haml.js

@@ -0,0 +1,651 @@
+var Haml;
+ 
+(function () {
+
+  var matchers, self_close_tags, embedder, forceXML, escaperName, escapeHtmlByDefault;
+
+  function html_escape(text) {
+    return (text + "").
+      replace(/&/g, "&").
+      replace(/</g, "&lt;").
+      replace(/>/g, "&gt;").
+      replace(/\"/g, "&quot;");
+  }
+
+  function render_attribs(attribs) {
+    var key, value, result = [];
+    for (key in attribs) {
+      if (key !== '_content' && attribs.hasOwnProperty(key)) {
+        switch (attribs[key]) {
+        case 'undefined':
+        case 'false':
+        case 'null':
+        case '""':
+          break;
+        default:
+          try {
+            value = JSON.parse("[" + attribs[key] +"]")[0];
+            if (value === true) {
+              value = key;
+            } else if (typeof value === 'string' && embedder.test(value)) {
+              value = '" +\n' + parse_interpol(html_escape(value)) + ' +\n"';
+            } else {
+              value = html_escape(value);
+            }
+            result.push(" " + key + '=\\"' + value + '\\"');
+          } catch (e) {
+            result.push(" " + key + '=\\"" + '+escaperName+'(' + attribs[key] + ') + "\\"');
+          }
+        }
+      }
+    }
+    return result.join("");
+  }
+
+  // Parse the attribute block using a state machine
+  function parse_attribs(line) {
+    var attributes = {},
+        l = line.length,
+        i, c,
+        count = 1,
+        quote = false,
+        skip = false,
+        open, close, joiner, seperator,
+        pair = {
+          start: 1,
+          middle: null,
+          end: null
+        };
+
+    if (!(l > 0 && (line.charAt(0) === '{' || line.charAt(0) === '('))) {
+      return {
+        _content: line[0] === ' ' ? line.substr(1, l) : line
+      };
+    }
+    open = line.charAt(0);
+    close = (open === '{') ? '}' : ')';
+    joiner = (open === '{') ? ':' : '=';
+    seperator = (open === '{') ? ',' : ' ';
+
+    function process_pair() {
+      if (typeof pair.start === 'number' &&
+          typeof pair.middle === 'number' &&
+          typeof pair.end === 'number') {
+        var key = line.substr(pair.start, pair.middle - pair.start).trim(),
+            value = line.substr(pair.middle + 1, pair.end - pair.middle - 1).trim();
+        attributes[key] = value;
+      }
+      pair = {
+        start: null,
+        middle: null,
+        end: null
+      };
+    }
+
+    for (i = 1; count > 0; i += 1) {
+
+      // If we reach the end of the line, then there is a problem
+      if (i > l) {
+        throw "Malformed attribute block";
+      }
+
+      c = line.charAt(i);
+      if (skip) {
+        skip = false;
+      } else {
+        if (quote) {
+          if (c === '\\') {
+            skip = true;
+          }
+          if (c === quote) {
+            quote = false;
+          }
+        } else {
+          if (c === '"' || c === "'") {
+            quote = c;
+          }
+
+          if (count === 1) {
+            if (c === joiner) {
+              pair.middle = i;
+            }
+            if (c === seperator || c === close) {
+              pair.end = i;
+              process_pair();
+              if (c === seperator) {
+                pair.start = i + 1;
+              }
+            }
+          }
+
+          if (c === open || c === "(") {
+            count += 1;
+          }
+          if (c === close || (count > 1 && c === ")")) {
+            count -= 1;
+          }
+        }
+      }
+    }
+    attributes._content = line.substr(i, line.length);
+    return attributes;
+  }
+
+  // Split interpolated strings into an array of literals and code fragments.
+  function parse_interpol(value) {
+    var items = [],
+        pos = 0,
+        next = 0,
+        match;
+    while (true) {
+      // Match up to embedded string
+      next = value.substr(pos).search(embedder);
+      if (next < 0) {
+        if (pos < value.length) {
+          items.push(JSON.stringify(value.substr(pos)));
+        }
+        break;
+      }
+      items.push(JSON.stringify(value.substr(pos, next)));
+      pos += next;
+
+      // Match embedded string
+      match = value.substr(pos).match(embedder);
+      next = match[0].length;
+      if (next < 0) { break; }
+      if(match[1] === "#"){
+        items.push(escaperName+"("+(match[2] || match[3])+")");
+      }else{
+        //unsafe!!!
+        items.push(match[2] || match[3]);
+      }
+      
+      pos += next;
+    }
+    return items.filter(function (part) { return part && part.length > 0}).join(" +\n");
+  }
+
+  // Used to find embedded code in interpolated strings.
+  embedder = /([#!])\{([^}]*)\}/;
+
+  self_close_tags = ["meta", "img", "link", "br", "hr", "input", "area", "base"];
+
+  // All matchers' regexps should capture leading whitespace in first capture
+  // and trailing content in last capture
+  matchers = [
+    // html tags
+    {
+      name: "html tags",
+      regexp: /^(\s*)((?:[.#%][a-z_\-][a-z0-9_:\-]*)+)(.*)$/i,
+      process: function () {
+        var line_beginning, tag, classes, ids, attribs, content, whitespaceSpecifier, whitespace={}, output;
+        line_beginning = this.matches[2];
+        classes = line_beginning.match(/\.([a-z_\-][a-z0-9_\-]*)/gi);
+        ids = line_beginning.match(/\#([a-z_\-][a-z0-9_\-]*)/gi);
+        tag = line_beginning.match(/\%([a-z_\-][a-z0-9_:\-]*)/gi);
+
+        // Default to <div> tag
+        tag = tag ? tag[0].substr(1, tag[0].length) : 'div';
+
+        attribs = this.matches[3];
+        if (attribs) {
+          attribs = parse_attribs(attribs);
+          if (attribs._content) {
+            var leader0 = attribs._content.charAt(0),
+                leader1 = attribs._content.charAt(1),
+                leaderLength = 0;
+                
+            if(leader0 == "<"){
+              leaderLength++;
+              whitespace.inside = true;
+              if(leader1 == ">"){
+                leaderLength++;
+                whitespace.around = true;
+              }
+            }else if(leader0 == ">"){
+              leaderLength++;
+              whitespace.around = true;
+              if(leader1 == "<"){
+                leaderLength++;
+                whitespace.inside = true;
+              }
+            }
+            attribs._content = attribs._content.substr(leaderLength);
+            //once we've identified the tag and its attributes, the rest is content.
+            // this is currently trimmed for neatness.
+            this.contents.unshift(attribs._content.trim());
+            delete(attribs._content);
+          }
+        } else {
+          attribs = {};
+        }
+
+        if (classes) {
+          classes = classes.map(function (klass) {
+            return klass.substr(1, klass.length);
+          }).join(' ');
+          if (attribs['class']) {
+            try {
+              attribs['class'] = JSON.stringify(classes + " " + JSON.parse(attribs['class']));
+            } catch (e) {
+              attribs['class'] = JSON.stringify(classes + " ") + " + " + attribs['class'];
+            }
+          } else {
+            attribs['class'] = JSON.stringify(classes);
+          }
+        }
+        if (ids) {
+          ids = ids.map(function (id) {
+            return id.substr(1, id.length);
+          }).join(' ');
+          if (attribs.id) {
+            attribs.id = JSON.stringify(ids + " ") + attribs.id;
+          } else {
+            attribs.id = JSON.stringify(ids);
+          }
+        }
+
+        attribs = render_attribs(attribs);
+
+        content = this.render_contents();
+        if (content === '""') {
+          content = '';
+        }
+        
+        if(whitespace.inside){
+          if(content.length==0){
+            content='"  "'
+          }else{
+            try{ //remove quotes if they are there
+              content = '" '+JSON.parse(content)+' "';
+            }catch(e){
+              content = '" "+\n'+content+'+\n" "';
+            }            
+          }
+        }
+
+        if (forceXML ? content.length > 0 : self_close_tags.indexOf(tag) == -1) {
+          output = '"<' + tag + attribs + '>"' +
+            (content.length > 0 ? ' + \n' + content : "") +
+            ' + \n"</' + tag + '>"';
+        } else {
+          output = '"<' + tag + attribs + ' />"';
+        }
+        
+        if(whitespace.around){
+          //output now contains '"<b>hello</b>"'
+          //we need to crack it open to insert whitespace.
+          output = '" '+output.substr(1, output.length - 2)+' "';
+        }
+
+        return output;
+      }
+    },
+
+    // each loops
+    {
+      name: "each loop",
+      regexp: /^(\s*)(?::for|:each)\s+(?:([a-z_][a-z_\-]*),\s*)?([a-z_][a-z_\-]*)\s+in\s+(.*)(\s*)$/i,
+      process: function () {
+        var ivar = this.matches[2] || '__key__', // index
+            vvar = this.matches[3],              // value
+            avar = this.matches[4],              // array
+            rvar = '__result__';                 // results
+
+        if (this.matches[5]) {
+          this.contents.unshift(this.matches[5]);
+        }
+        return '(function () { ' +
+          'var ' + rvar + ' = [], ' + ivar + ', ' + vvar + '; ' +
+          'for (' + ivar + ' in ' + avar + ') { ' +
+          'if (' + avar + '.hasOwnProperty(' + ivar + ')) { ' +
+          vvar + ' = ' + avar + '[' + ivar + ']; ' +
+          rvar + '.push(\n' + (this.render_contents() || "''") + '\n); ' +
+          '} } return ' + rvar + '.join(""); }).call(this)';
+      }
+    },
+
+    // if statements
+    {
+      name: "if",
+      regexp: /^(\s*):if\s+(.*)\s*$/i,
+      process: function () {
+        var condition = this.matches[2];
+        return '(function () { ' +
+          'if (' + condition + ') { ' +
+          'return (\n' + (this.render_contents() || '') + '\n);' +
+          '} else { return ""; } }).call(this)';
+      }
+    },
+    
+    // silent-comments
+    {
+      name: "silent-comments",
+      regexp: /^(\s*)-#\s*(.*)\s*$/i,
+      process: function () {
+        return '""';
+      }
+    },
+    
+    //html-comments
+    {
+      name: "silent-comments",
+      regexp: /^(\s*)\/\s*(.*)\s*$/i,
+      process: function () {
+        this.contents.unshift(this.matches[2]);
+        
+        return '"<!--'+this.contents.join('\\n')+'-->"';
+      }
+    },
+    
+    // raw js
+    {
+      name: "rawjs",
+      regexp: /^(\s*)-\s*(.*)\s*$/i,
+      process: function () {
+        this.contents.unshift(this.matches[2]);
+        return '"";' + this.contents.join("\n")+"; _$output = _$output ";
+      }
+    },
+
+    // raw js
+    {
+      name: "pre",
+      regexp: /^(\s*):pre(\s+(.*)|$)/i,
+      process: function () {
+        this.contents.unshift(this.matches[2]);
+        return '"<pre>"+\n' + JSON.stringify(this.contents.join("\n"))+'+\n"</pre>"';
+      }
+    },
+    
+    // declarations
+    {
+      name: "doctype",
+      regexp: /^()!!!(?:\s*(.*))\s*$/,
+      process: function () {
+        var line = '';
+        switch ((this.matches[2] || '').toLowerCase()) {
+        case '':
+          // XHTML 1.0 Transitional
+          line = '<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">';
+          break;
+        case 'strict':
+        case '1.0':
+          // XHTML 1.0 Strict
+          line = '<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">';
+          break;
+        case 'frameset':
+          // XHTML 1.0 Frameset
+          line = '<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Frameset//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-frameset.dtd">';
+          break;
+        case '5':
+          // XHTML 5
+          line = '<!DOCTYPE html>';
+          break;
+        case '1.1':
+          // XHTML 1.1
+          line = '<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.1//EN" "http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd">';
+          break;
+        case 'basic':
+          // XHTML Basic 1.1
+          line = '<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML Basic 1.1//EN" "http://www.w3.org/TR/xhtml-basic/xhtml-basic11.dtd">';
+          break;
+        case 'mobile':
+          // XHTML Mobile 1.2
+          line = '<!DOCTYPE html PUBLIC "-//WAPFORUM//DTD XHTML Mobile 1.2//EN" "http://www.openmobilealliance.org/tech/DTD/xhtml-mobile12.dtd">';
+          break;
+        case 'xml':
+          // XML
+          line = "<?xml version='1.0' encoding='utf-8' ?>";
+          break;
+        case 'xml iso-8859-1':
+          // XML iso-8859-1
+          line = "<?xml version='1.0' encoding='iso-8859-1' ?>";
+          break;
+        }
+        return JSON.stringify(line + "\n");
+      }
+    },
+
+    // Embedded markdown. Needs to be added to exports externally.
+    {
+      name: "markdown",
+      regexp: /^(\s*):markdown\s*$/i,
+      process: function () {
+        return parse_interpol(exports.Markdown.encode(this.contents.join("\n")));
+      }
+    },
+
+    // script blocks
+    {
+      name: "script",
+      regexp: /^(\s*):(?:java)?script\s*$/,
+      process: function () {
+        return parse_interpol('\n<script type="text/javascript">\n' +
+          '//<![CDATA[\n' +
+          this.contents.join("\n") +
+          "\n//]]>\n</script>\n");
+      }
+    },
+
+    // css blocks
+    {
+      name: "css",
+      regexp: /^(\s*):css\s*$/,
+      process: function () {
+        return JSON.stringify('<style type="text/css">\n' +
+          this.contents.join("\n") +
+          "\n</style>");
+      }
+    }
+
+  ];
+
+  function compile(lines) {
+    var block = false,
+        output = [];
+
+    // If lines is a string, turn it into an array
+    if (typeof lines === 'string') {
+      lines = lines.trim().replace(/\n\r|\r/g, '\n').split('\n');
+    }
+
+    lines.forEach(function(line) {
+      var match, found = false;
+
+      // Collect all text as raw until outdent
+      if (block) {
+        match = block.check_indent.exec(line);
+        if (match) {
+          block.contents.push(match[1] || "");
+          return;
+        } else {
+          output.push(block.process());
+          block = false;
+        }
+      }
+
+      matchers.forEach(function (matcher) {
+        if (!found) {
+          match = matcher.regexp.exec(line);
+          if (match) {
+            block = {
+              contents: [],
+              indent_level: (match[1]),
+              matches: match,
+              check_indent: new RegExp("^(?:\\s*|" + match[1] + "  (.*))$"),
+              process: matcher.process,
+              render_contents: function () {
+                return compile(this.contents);
+              }
+            };
+            found = true;
+          }
+        }
+      });
+
+      // Match plain text
+      if (!found) {
+        output.push(function () {
+          // Escaped plain text
+          if (line[0] === '\\') {
+            return parse_interpol(line.substr(1, line.length));
+          }
+
+
+          function escapedLine(){
+            try {
+              return escaperName+'('+JSON.stringify(JSON.parse(line)) +')';
+            } catch (e2) {
+              return escaperName+'(' + line + ')';
+            }
+          }
+          
+          function unescapedLine(){
+            try {
+              return parse_interpol(JSON.parse(line));
+            } catch (e) {
+              return line;
+            }
+          }
+          
+          // always escaped
+          if((line.substr(0, 2) === "&=")) {
+            line = line.substr(2, line.length).trim();
+            return escapedLine();
+          }
+          
+          //never escaped
+          if((line.substr(0, 2) === "!=")) {
+            line = line.substr(2, line.length).trim();
+            return unescapedLine();
+          }
+          
+          // sometimes escaped
+          if ( (line[0] === '=')) {
+            line = line.substr(1, line.length).trim();
+            if(escapeHtmlByDefault){
+              return escapedLine();
+            }else{
+              return unescapedLine();
+            }
+          }
+
+          // Plain text
+          return parse_interpol(line);
+        }());
+      }
+
+    });
+    if (block) {
+      output.push(block.process());
+    }
+    
+    var txt = output.filter(function (part) { return part && part.length > 0}).join(" +\n");
+    if(txt.length == 0){
+      txt = '""';
+    }
+    return txt;
+  };
+
+  function optimize(js) {
+    var new_js = [], buffer = [], part, end;
+
+    function flush() {
+      if (buffer.length > 0) {
+        new_js.push(JSON.stringify(buffer.join("")) + end);
+        buffer = [];
+      }
+    }
+    js.replace(/\n\r|\r/g, '\n').split('\n').forEach(function (line) {
+      part = line.match(/^(\".*\")(\s*\+\s*)?$/);
+      if (!part) {
+        flush();
+        new_js.push(line);
+        return;
+      }
+      end = part[2] || "";
+      part = part[1];
+      try {
+        buffer.push(JSON.parse(part));
+      } catch (e) {
+        flush();
+        new_js.push(line);
+      }
+    });
+    flush();
+    return new_js.join("\n");
+  };
+
+  function render(text, options) {
+    options = options || {};
+    text = text || "";
+    var js = compile(text, options);
+    if (options.optimize) {
+      js = Haml.optimize(js);
+    }
+    return execute(js, options.context || Haml, options.locals);
+  };
+
+  function execute(js, self, locals) {
+    return (function () {
+      with(locals || {}) {
+        try {
+          var _$output;
+          eval("_$output =" + js );
+          return _$output; //set in eval
+        } catch (e) {
+          return "\n<pre class='error'>" + html_escape(e.stack) + "</pre>\n";
+        }
+
+      }
+    }).call(self);
+  };
+
+  Haml = function Haml(haml, config) {
+    if(typeof(config) != "object"){
+      forceXML = config;
+      config = {};
+    }
+    
+    var escaper;
+    if(config.customEscape){
+      escaper = "";
+      escaperName = config.customEscape;
+    }else{
+      escaper = html_escape.toString() + "\n";
+      escaperName = "html_escape";
+    }
+    
+    escapeHtmlByDefault = (config.escapeHtmlByDefault || config.escapeHTML || config.escape_html);
+    
+    var js = optimize(compile(haml));
+    
+    var str = "with(locals || {}) {\n" +
+    "  try {\n" +
+    "   var _$output=" + js + ";\n return _$output;" +
+    "  } catch (e) {\n" +
+    "    return \"\\n<pre class='error'>\" + "+escaperName+"(e.stack) + \"</pre>\\n\";\n" +
+    "  }\n" +
+    "}"
+
+    try{
+      var f = new Function("locals",  escaper + str );
+      return f;
+    }catch(e){
+      console.error(str);
+      throw e;
+    }
+  }
+
+  Haml.compile = compile;
+  Haml.optimize = optimize;
+  Haml.render = render;
+  Haml.execute = execute;
+  Haml.html_escape = html_escape;
+}());
+
+// Hook into module system
+if (typeof module !== 'undefined') {
+  module.exports = Haml;
+}

metadata

@@ -0,0 +1,125 @@
+--- !ruby/object:Gem::Specification
+name: herman-haml-sprockets
+version: !ruby/object:Gem::Version
+  version: 0.0.8
+  prerelease: 
+platform: ruby
+authors:
+- vagmi
+- Herman Moreno
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-09-25 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: tilt
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: sprockets
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: execjs
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.3.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.3.0
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Use the JST processor and have haml code read in and appended to application.js
+email:
+- vagmi.mudumbai@gmail.com
+- herman.moreno@crowdint.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- haml-sprockets.gemspec
+- lib/haml-sprockets.rb
+- lib/haml-sprockets/engine.rb
+- lib/haml-sprockets/version.rb
+- spec/lib/haml-sprockets_spec.rb
+- spec/spec_helper.rb
+- vendor/assets/javascripts/haml.js
+homepage: https://github.com/supherman/haml-sprockets
+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: herman-haml-sprockets
+rubygems_version: 1.8.23
+signing_key: 
+specification_version: 3
+summary: Use the awesome haml-js javascript templating lib in Ruby
+test_files:
+- spec/lib/haml-sprockets_spec.rb
+- spec/spec_helper.rb