haml_coffee_assets 0.0.1

data/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2011 Michael Kessler <michi@netzpiraten.ch>
+
+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,260 @@
+# HamlCoffeeAssets [![Build Status](https://secure.travis-ci.org/netzpirat/haml_coffee_assets.png)](http://travis-ci.org/netzpirat/haml_coffee_assets)
+
+HamlCoffeeAssets compiles [Haml CoffeeScript](https://github.com/9elements/haml-coffee) templates in the Rails 3.1 asset
+pipeline.
+
+Tested on MRI Ruby 1.8.7, 1.9.2, REE and the latest versions of JRuby.
+
+## HamlCoffee
+
+HamlCoffee allows you to write inline [CoffeeScript](http://jashkenas.github.com/coffee-script/) in your
+[HAML](http://haml-lang.com/) template:
+
+```haml
+#cart
+  %h2= I18n.t('js.cart.title')
+  - if @cart.length == 0
+    %p.empty= I18n.t('js.cart.empty')
+  - else
+    %ul
+      - for item in @cart
+        %li
+          .item
+            = item.name
+            %a{ :href => "/cart/item/remove/#{ item.id }" }
+              = I18n.t('js.cart.item.remove')
+```
+
+## Installation
+
+The simplest way to install Guard is to use [Bundler](http://gembundler.com/).
+Add `haml_coffee_assets` and `execjs` to your `Gemfile`:
+
+```ruby
+group :assets do
+  gem 'haml_coffee_assets'
+  gem 'execjs'
+end
+```
+
+And require the `hamlcoffee.js` in your `application.js.coffee`
+
+```coffeescript
+#= require hamlcoffee
+```
+
+### JavaScript runtimes
+
+HamlCoffeeAssets uses [ExecJS](https://github.com/sstephenson/execjs) to pick the best runtime to evaluate the
+CoffeeScript and generate the JavaScript template.
+
+* With CRuby you want to use a V8 JavaScript Engine or Mozilla SpiderMonkey.
+* With JRuby you want to use the Mozilla Rhino.
+* On Mac OS X you want to use Apple JavaScriptCore.
+* On Linux or as a node.js developer you want to use Node.js (V8).
+* On Windows you want to use Microsoft Windows Script Host.
+
+The following sections gives you a short overview of the available JavaScript runtimes and how to install it.
+
+### Node.js (V8)
+
+You can install [node.js](http://nodejs.org/) and use its V8 engine. On OS X you may want to install it with
+[Homebrew](http://mxcl.github.com/homebrew/), on Linux with your package manager and on Windows you have to download and
+install the [executable](http://www.nodejs.org/#download).
+
+### V8 JavaScript Engine
+
+To use the [V8 JavaScript Engine](http://code.google.com/p/v8/), simple add `therubyracer` to your `Gemfile`.
+The Ruby Racer acts as a bridge between Ruby and the V8 engine, that will be automatically installed by the Ruby Racer.
+
+```ruby
+group :development do
+  gem 'therubyracer'
+end
+```
+
+Another alternative is [Mustang](https://github.com/nu7hatch/mustang), a Ruby proxy library for the awesome Google V8
+JavaScript engine. Just add `mustang` to your `Gemfile`:
+
+```ruby
+group :development do
+  gem 'mustang'
+end
+```
+
+### Mozilla SpiderMonkey
+
+To use [Mozilla SpiderMonkey](https://developer.mozilla.org/en/SpiderMonkey), simple add `johnson` to your `Gemfile`.
+Johnson embeds the Mozilla SpiderMonkey JavaScript runtime as a C extension.
+
+```ruby
+group :development do
+  gem 'johnson'
+end
+```
+
+### Mozilla Rhino
+
+If you're using JRuby, you can embed the [Mozilla Rhino](http://www.mozilla.org/rhino/) runtime by adding `therubyrhino`
+to your `Gemfile`:
+
+```ruby
+group :development do
+  gem 'therubyrhino'
+end
+```
+
+### Apple JavaScriptCore
+
+[JavaScriptCore](http://developer.apple.com/library/mac/#documentation/Carbon/Reference/WebKit_JavaScriptCore_Ref/index.html)
+is Safari's Nitro JavaScript Engine and only usable on Mac OS X. You don't have to install anything, because
+JavaScriptCore is already packaged with Mac OS X.
+
+### Microsoft Windows Script Host
+
+[Microsoft Windows Script Host](http://msdn.microsoft.com/en-us/library/9bbdkx3k.aspx) is available on any Microsoft
+Windows operating systems.
+
+## Usage
+
+You should place all your HamlCoffee templates in the `app/assets/templates` directory and include all templates in
+your `application.js.coffee`:
+
+```coffeescript
+#= require_tree ../templates
+```
+
+Now you can start to add your HamlCoffee templates to your template directory. Make sure all your templates have a
+`.hamlc` extension to be recognized by HamlCoffeeAssets.
+
+**Note:** HamlCoffee already generates a JavaScript Template, so there is not need to pass it to the `JST` Sprocket
+processor by using `.jst.hamlc` as extension, and if you do, the HamlCoffee templates will not work.
+
+## Configuration
+
+### Template namespace
+
+By default all HamlCoffee templates are registered under the `JST` namespace.
+
+Example:
+
+A template located in `app/assets/templates/header.hamlc` with the given content:
+
+```haml
+%header
+  %h2= title
+```
+
+will be accessible in your browser as `JST.header`. You can now render the precompiled template with:
+
+```javascript
+JST.header.render({ title: 'Hello HamlCoffee' })
+```
+
+If you prefer another namespace, you can set it in your `application.rb`:
+
+```ruby
+config.hamlcoffee.namespace = 'HAML'
+```
+
+### Escaping
+
+By default your code block in your HamlCoffee template will be escaped through the `HAML.escape` function that is
+provided in the `haml_coffee_assets.js`.
+
+You can set another escaping function in your `application.rb`:
+
+```ruby
+config.hamlcoffee.escape = 'App.myEscape'
+```
+
+or disable escaping completely:
+
+```ruby
+config.hamlcoffee.escape = false
+```
+
+Your custom escape function must take the unescaped text as parameter and returns the escape function.
+The following example implements only ampersand escaping:
+
+```coffeescript
+App.myEscape = (text) -> text.replace(/&/g, '&')
+```
+
+### Global Context
+
+HamlCoffeeAssets allows you to configure a global context function that gets merged into the local template context for
+each template.
+
+There is a example implementation provided in the `haml_coffee_assets.js` that uses the `extend` function
+from these frameworks:
+
+* jQuery
+* Underscore.js
+* Prototype
+* MooTools
+* Zepto.js
+
+If you use one of these, than you can simply override `HAML.globals` and return the global HAML context object:
+
+```coffeescript
+HAML.globals = ->
+  {
+    authenticated: App.isAuthenticated()
+    isAdmin: App.currentUser.hasRole('admin')
+  }
+```
+
+If you like to use your own implementation, simply configure your context function in your `application.rb`:
+
+```ruby
+config.hamlcoffee.context = 'App.globalTemplateContext'
+```
+
+or disable the global context completely:
+
+```ruby
+config.hamlcoffee.context = false
+```
+
+Your custom context function must take the local context as parameter and returns the merged context function.
+The following example implementation used the _.underscore extend function to merge an inline defined global
+context:
+
+```coffeescript
+App.globalTemplateContext = (locals) -> _.extend({}, {
+    authenticated: App.isAuthenticated()
+}, locals)
+```
+
+## Acknowledgement
+
+* [Jeremy Ashkenas](http://twitter.com/#!/jashkenas) for CoffeeScript, that little language that compiles into
+  JavaScript.
+* The people at [9elements](https://github.com/9elements) who gave us
+  [haml-coffee](https://github.com/9elements/haml-coffee), an elegant JavaScript template solution.
+
+## License
+
+(The MIT License)
+
+Copyright (c) 2011 Michael Kessler
+
+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/lib/haml_coffee_assets.rb

@@ -0,0 +1,13 @@
+# coding: UTF-8
+
+require 'pathname'
+
+require 'rails'
+require 'tilt'
+require 'sprockets'
+require 'execjs'
+
+require 'haml_coffee_assets/version'
+require 'haml_coffee_assets/haml_coffee'
+require 'haml_coffee_assets/haml_coffee_template'
+require 'haml_coffee_assets/engine'

data/lib/haml_coffee_assets/engine.rb

@@ -0,0 +1,36 @@
+# coding: UTF-8
+
+module HamlCoffeeAssets
+
+  # Hook the Haml CoffeeScript template into a Rails app.
+  #
+  class Engine < Rails::Engine
+
+    config.hamlcoffee = ActiveSupport::OrderedOptions.new
+
+    DEFAULT_CONFIG = {
+        :namespace => 'HAML',
+        :escape    => 'HAML.escape',
+        :context   => 'HAML.context'
+    }
+
+    # Initialize Haml Coffee Assets after Sprockets
+    #
+    initializer 'sprockets.hamlcoffeeassets', :after => 'sprockets.environment' do |app|
+      next unless app.assets
+
+      # Register tilt template
+      app.assets.register_engine '.hamlc', HamlCoffeeTemplate
+
+      # Set application configuration for the HAML templates.
+      options = DEFAULT_CONFIG.merge(app.config.hamlcoffee)
+
+      HamlCoffee.configure do |config|
+        config.namespace = options[:namespace]
+        config.escape    = options[:escape]
+        config.context   = options[:context]
+      end
+    end
+
+  end
+end

data/lib/haml_coffee_assets/haml_coffee.rb

@@ -0,0 +1,72 @@
+# coding: UTF-8
+
+module HamlCoffeeAssets
+
+  # Handles compilation of Haml CoffeeScript templates to pure JavaScript.
+  #
+  module HamlCoffee
+    class << self
+
+      mattr_accessor :namespace, :escape, :context
+
+      # Configure HamlCoffee
+      #
+      def configure
+        yield self
+      end
+
+      # Compile the Haml CoffeeScript template.
+      #
+      # @param [String] name the template name
+      # @param [String] source the template source code
+      # @return [String] the compiled template in JavaScript
+      #
+      def compile(name, source)
+        runtime.call('HamlCoffeeAssets.compile', namespace, name, source, escape, context)
+      end
+
+      private
+
+      # Get the context to compile Haml CoffeeScript templates.
+      #
+      # @return [Runtime] the JS runtime
+      #
+      def runtime
+        @runtime ||= ExecJS.compile(source)
+      end
+
+      # Get the combined source of haml-coffee and CoffeeScript.
+      #
+      # @return [String] the source code
+      #
+      def source
+        coffeescript + ';' + haml_coffee + ';' + haml_coffee_assets
+      end
+
+      # Get the Haml CoffeeScript Assets source code.
+      #
+      # @return [String] the source
+      #
+      def haml_coffee_assets
+        Pathname.new(__FILE__).dirname.join('haml_coffee_assets.js').read
+      end
+
+      # Get the Haml CoffeeScript source code.
+      #
+      # @return [String] the source
+      #
+      def haml_coffee
+        Pathname.new(__FILE__).dirname.join('..', 'js', 'haml-coffee.js').read
+      end
+
+      # Get the CoffeeScript source code.
+      #
+      # @return [String] the source
+      #
+      def coffeescript
+        Pathname.new(__FILE__).dirname.join('..', 'js', 'coffee-script.js').read
+      end
+
+    end
+  end
+end

data/lib/haml_coffee_assets/haml_coffee_assets.js

@@ -0,0 +1,64 @@
+/**
+ * Fix for the Ruby Rhino
+ */
+if (!String.prototype.trim) {
+    String.prototype.trim = function () {
+        return this.replace(/^\s*/, "").replace(/\s*$/, "");
+    }
+}
+
+/**
+ * Haml Coffee Asset compiler.
+ */
+var HamlCoffeeAssets = (function(){
+
+    var Compiler = require('/compiler.js');
+
+    /**
+     * Test if the argument is present
+     *
+     * @param object [Object] the object to test
+     * @return [Boolean] whether the object is present
+     */
+    function isPresent(object) {
+      return toString.call(object) === '[object String]' && object.length !== 0
+    }
+
+    return {
+
+      /**
+       * Compile the HAML Coffee template to JavaScript
+       *
+       * @param namespace [String] the template namespace
+       * @param name [String] the name of the template that is registered to the namespace
+       * @param source [String] the template source code to be compiled
+       * @param escape [String] the name of the function to escape the output
+       * @param context [String] the name of the function to merge contexts
+       */
+      compile: function(namespace, name, source, escape, context) {
+
+        var compiler, jst;
+
+        if (!isPresent(namespace)) {
+           namespace = 'HAML'
+        }
+
+        if (isPresent(escape)) {
+          compiler = new Compiler({ escape_html: true, custom_html_escape: escape });
+        } else {
+          compiler = new Compiler({ escape_html: false });
+        }
+
+        compiler.parse(source);
+
+        jst = CoffeeScript.compile(compiler.render(name, namespace));
+
+        if (isPresent(context)) {
+          jst = jst.replace('fn.call(context);', 'fn.call(' + context +'(context));');
+        }
+
+        return jst;
+      }
+
+    }
+ })();