dry_haml_handlebars 0.0.4

data/.gitignore

@@ -0,0 +1,4 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*

data/.project

@@ -0,0 +1,18 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+	<name>dry_haml_handlebars</name>
+	<comment></comment>
+	<projects>
+	</projects>
+	<buildSpec>
+		<buildCommand>
+			<name>com.aptana.ide.core.unifiedBuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+	</buildSpec>
+	<natures>
+		<nature>org.radrails.rails.core.railsnature</nature>
+		<nature>com.aptana.ruby.core.rubynature</nature>
+	</natures>
+</projectDescription>

data/.rvmrc

@@ -0,0 +1 @@
+rvm use ruby-1.9.2-p180@dry_haml_handlebars --create

data/Gemfile

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

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2010 [name of plugin creator]
+
+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,76 @@
+**NOTE** this gem is work in progress, I'll flesh out the instructions once it's stabilized
+
+dry_haml_handlebars plugin
+============
+
+This gem may be of use to you if:
+
+* angle brackets burn your eyes (read: you like using haml)
+  * NOTE: if you're fine with angle brackets, stop reading, you're probably better off just using mustache
+  * see http://railscasts.com/episodes/295-sharing-mustache-templates
+* you want your app to consume its own API and do most rendering clientside (e.g. using backbone.js, spine.js etc.)
+* but you still need to render server-side (so the googlebot and paranoid no-js people can see your lovely, lovely content)
+* and, importantly, you prefer DRY apps to WET ones (i.e. you don't want to write equivalent clientside and serverside templates)
+
+Still here? Ok, this gem lets you:
+
+* write templates using a haml/handlebars.js hybrid
+* the haml describes the structure of the document while the handlebars syntax is used for substitution and logical flow
+* it assumes you are using the rabl gem to generate JSON data for your view
+
+What it does is:
+
+* convert your hybrid templates to valid haml in which the handlebars markup is just treated as text
+* then runs that through the standard haml handler to generate regular handlebars templates (html + curly braces)
+* when rendering serverside it uses execjs and your rabl-generated JSON to render the template
+* but it also ships pre-compiled versions of your templates and JSON data to the client (using the gon gem) so that you can switch to clientside rendering for subsequent requests
+
+Installation
+=======
+
+Add this to your Gemfile if using Bundler: `gem 'dry_haml_handlebars'`
+
+Or install the gem from the command line: `gem install dry_haml_handlebars`
+
+Setup
+=======
+
+Usage
+=====
+
+Hybrid haml/handlebars syntax
+-----------------------------
+
+The syntax for your templates is a readable mix of haml and handlebars:
+
+```haml
+.entry
+  .h1 {{title}}
+  {{#if subtitle}}
+    .h2 {{subtitle}}
+  {{/if}}
+  .h3 By
+    = link_to "{{author.name}}", user_path("{{author.id}}"), 'data-remote' => true
+  posted at {{localize created_at}}
+  .body
+    {{{body}}}
+```
+
+Benefits:
+
+* the brevity and structural clarity that haml provides
+* the ability to use standard rails helpers to generate html
+* concise flow constrol and substitution via handlebars
+* the ability to use custom handlebars helpers (e.g. localize)
+* seamless integration with your JSON API - structure the JSON (via rabl), then structure the view around it
+
+*more to follow...*
+
+Acknowledgements
+================
+
+Thanks to the authors of:
+
+* the handlebars gem (made server side compilation easy)
+
+Copyright (c) 2012 PeepAll Ltd, released under the MIT license

data/Rakefile

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

data/dry_haml_handlebars.gemspec

@@ -0,0 +1,30 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "dry_haml_handlebars/version"
+
+Gem::Specification.new do |s|
+  s.name        = "dry_haml_handlebars"
+  s.version     = DryHamlHandlebars::VERSION
+  s.authors     = ["Jonathan Chambers"]
+  s.email       = ["j.chambers@gmx.net"]
+  s.homepage    = "https://github.com/jmchambers/dry_haml_handlebars"
+  s.summary     = "Write haml templates, use both server and clientside (via handlebars.js)"
+  s.description = "Write haml views once, and then use them for both server and clientside rendering (using automagically precompiled handlebars templates)"
+
+  s.rubyforge_project = "dry_haml_handlebars"
+
+  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"]
+  
+  s.add_dependency "rails",             "~> 3.2.0"
+  s.add_dependency "therubyracer"
+  s.add_dependency "haml-rails",        "~> 0.3.4"
+  s.add_dependency "handlebars_assets", "~> 0.4.4" # was "~> 0.4.4"
+  s.add_dependency "rabl",              "0.7.1"   # "0.6.12"    #this is locked down because the author's minor increments consistently break everything, grrrrr!
+  s.add_dependency "gon",               "~> 3.0.2"
+  
+  s.license       = 'MIT'
+  
+end

data/lib/action_controller/base.rb

@@ -0,0 +1,80 @@
+module ActionController
+  class Base
+    
+    def render_extra_content_for(*args)
+      options = args.extract_options!
+      args.each do |identifier|
+        name, path = get_content_for_name_and_path(identifier, options)
+        DryHamlHandlebars.content_cache.add_item(name, path)
+      end
+      
+    end
+      
+    private
+    
+    def get_content_for_name_and_path(identifier, options)
+      
+      case identifier
+      when Symbol
+        
+        name = identifier
+        
+        possible_folders = [
+          Rails.root.join( *%w[app views] << params[:controller] ).to_s,
+          Rails.root.join( *%w[app views application] ).to_s
+        ]
+        
+        if folders = options[:prepend_search_folders]
+          possible_folders = folders + possible_folders
+        end
+        
+        if folders = options[:append_search_folders]
+          possible_folders += folders
+        end
+        
+        possible_filenames = [
+          "#{params[:action]}_#{name}.html.haml",
+          "#{name}.html.haml",
+          "#{params[:action]}_content_for_#{name}.html.haml",
+          "content_for_#{name}.html.haml"
+        ]
+        
+        possible_paths = []
+        
+        possible_folders.each do |folder|
+          possible_filenames.each do |fname|
+            possible_paths << File.join( folder, fname )
+          end
+        end
+        
+        path = possible_paths.find { |p| File.exist?(p) }
+        raise "couldn't find any of the following expected files:\n#{possible_paths.join("\n")}" if path.nil?
+        
+      when Array
+        
+        path = Rails.root.join( *%w[app views] << "#{identifier.last}.html.haml" ).to_s
+        name = identifier.first.to_sym
+      
+      when String
+        
+        path = Rails.root.join( *%w[app views] << "#{identifier}.html.haml" ).to_s
+        name_match = identifier.match(/.*content_for_(?<name>\w*)/)
+        if name_match
+          name = name_match[:name].to_sym
+        else
+          name = identifier
+        end
+        
+      else
+        raise ArgumentError, "expected identifier to be a Array, Symbol or String, but got #{identifier}"
+      end
+      
+      raise "the file #{path} does not exist" unless File.exist?(path)
+
+      return name, path
+    
+    end
+
+    
+  end
+end

data/lib/action_view/base.rb

@@ -0,0 +1,31 @@
+module ActionView
+  class Base
+
+    def handlebars_render(*args, &block)
+      
+      #we simply wrap render so that we can detect that 'handlebars_render' was the calling function
+      #we do this by adding a local variable :handlebars_partial => true
+      
+      if args.first.is_a?(Hash)
+        
+        options = args.first
+        options[:locals] ||= {}
+        options[:locals].merge!(:__handlebars_partial => true)
+        
+      elsif args.last.is_a?(Hash)
+        
+        locals = args.last
+        locals[:__handlebars_partial] = true
+      
+      else
+
+        args << {:__handlebars_partial => true}
+
+      end
+      
+      render(*args, &block)
+      
+    end
+
+  end
+end

data/lib/action_view/helpers/capture_helper.rb

@@ -0,0 +1,20 @@
+module ActionView
+  module Helpers
+    module CaptureHelper
+      
+      # WARNING: content_for is ignored in caches. So you shouldn't use it
+      # for elements that will be fragment cached.
+      def handlebars_content_for(name, content = nil, flush = false)
+        
+        if content
+          flush ? @view_flow.set(name, content) : @view_flow.append(name, content)
+          nil
+        else
+          @view_flow.get(name)
+        end
+        
+      end
+      
+    end
+  end
+end

data/lib/dry_haml_handlebars/handler.rb

@@ -0,0 +1,395 @@
+module DryHamlHandlebars
+  
+  INDENT      = /\A(?<indent>\s*)/
+  CONTENT     = /#{INDENT}\S+.*\Z/
+  BLOCK_START = /(?<start>#{INDENT}{{#(?<keyword>\w+))/
+  
+  require 'haml/template/plugin'
+  
+  def self.dedent_hbs(source)
+    lines = source.lines.to_a
+    mod_lines = lines.clone
+    lines.each_with_index do |line1, i1|
+      
+      if (l1_match = line1.match BLOCK_START)
+        
+        l1_index  = i1
+        l1_indent = l1_match[:indent] ? l1_match[:indent].length : 0
+        l1_text   = l1_match[:start]
+        
+        #binding.pry if i1 == 7
+    
+        next_match = nil
+        next_line = lines[l1_index+1..-1].detect { |l| next_match = l.match(CONTENT) }
+        
+        next unless next_match
+        next_line_indent = next_match[:indent] ? next_match[:indent].length : 0
+        next unless (indent = next_line_indent - l1_indent) > 0
+        
+        
+        l2_text   = l1_text.sub("{{#", "{{/")
+        else_text = " " * l1_indent + "{{else}}"
+        else_index = nil
+        l2_index = lines[l1_index+1..-1].each_with_index.each do |line2, i2|
+          else_index = i2 if line2.starts_with? else_text
+          break i2 + l1_index+1 if line2.starts_with? l2_text
+        end
+    
+        (l1_index+1..l2_index-1).each_with_index do |index, i|
+          next if i == else_index
+          mod_lines[index] = mod_lines[index][indent..-1]
+        end
+        
+      end
+    end
+    mod_lines.join
+  end
+  
+  class << self  
+    attr_accessor :on_next_request
+  end
+  
+  class Handler < Haml::Plugin
+    
+    class << self
+    
+      def call(template, options = {})
+  
+        view_match         = template.identifier.match(/^#{Rails.root.join('app', 'views')}[\/](?<view_path>[\/\w]+)[\/](?<view_name>\w+).html/)
+        relative_view_path = view_match[:view_path]
+        view_name          = view_match[:view_name]
+        view_type          = get_view_type(template, relative_view_path, view_name)
+        
+        env = Rails.env.to_sym
+        out = []
+  
+        #when in dev mode we can set this variable to true on each request (in the app controller)
+        #and we scan for all changed partials (whether needed for the current view or not)
+        #this is intended to ensure that all changes are picked up ready for deployment
+        #even if the dev forgets to run the view that requires a changed partial
+        #the rule is, render ANY page, and ALL partials should be re-compiled (if needed)
+        #while for changed templates, you MUST run the view that you have changed
+        if DryHamlHandlebars.on_next_request.values.any?
+          DryHamlHandlebars.on_next_request.keys.each do |method|
+            DryHamlHandlebars.on_next_request[method] = false
+            case method
+            when :compile_all_partials
+              out += compile_and_load_all_partials
+            else
+              DryHamlHandlebars.send method
+            end
+          end
+        end
+  
+        if [:layout, :ignored_partial].include? view_type
+          out << super(template)
+          return out.join("\n")
+        end
+  
+        partial_name = [relative_view_path.gsub('/', '_'), view_name[1..-1]].join('_')
+        rabl_path, template_path, compiled_template_path = generate_file_names(relative_view_path, view_name)
+        if options[:force_handlebars_compile] or !File.exist?(compiled_template_path) or ( [:development, :test].include?(env) and ( File.mtime(compiled_template_path) < File.mtime(template.identifier) ) )
+          source = template.source
+          source = DryHamlHandlebars.dedent_hbs(source)
+          template.instance_variable_set "@source", source
+          rendered_haml = <<-RUBY
+            rendered_haml = eval(%q( #{super(template)} )).html_safe
+          RUBY
+        else
+          rendered_haml = nil
+        end
+        
+        runner = Runner.new(
+          template,
+          rendered_haml,
+          view_type,
+          view_name,
+          partial_name,
+          relative_view_path,
+          rabl_path,
+          template_path,
+          compiled_template_path
+        )
+        
+        out << runner.run
+        out.join("\n")
+          
+      end
+      
+      def compile_and_load_all_partials
+        partials = Dir.glob(Rails.root.join('app', 'views', '**', '_*.html.haml'))
+        out = []
+        partials.each do |fname|
+          File.open(fname) do |file|
+            source = file.read
+            next unless source.starts_with?('-#handlebars_partial')
+            source = DryHamlHandlebars.dedent_hbs(source)
+            template = ActionView::Template.new(source, fname, nil, {:locals => ["__handlebars_partial"]})
+            out << call(template, :force_handlebars_compile => true)
+          end
+        end
+        out
+      end
+        
+      def get_view_type(template, relative_view_path, view_name)
+        
+        #we have 4 types of view;
+        # 1) layout           - always handled by haml, no hbs/js versions are generated
+        # 2) template         - rendered as handlebars, we expect there to be html.haml AND .rabl for the JSON
+        # 3) partial          - pulled into view by handlebars syntax {{>name}}
+        # 4) ignored_partial  - a regular partial, it will be rendered by Haml, with no handlebars-related processing
+        
+        if relative_view_path == 'layouts'
+          :layout
+        elsif template.locals.include?("__handlebars_partial")
+          :partial
+        elsif view_name.starts_with? "_"
+          :ignored_partial
+        else
+          :template
+        end
+              
+      end
+      
+      def generate_file_names(relative_view_path, view_name)
+        
+        template_partial_path           = Rails.root.join( *%w(app assets templates)          << "#{relative_view_path}" )
+        compiled_template_partial_path  = Rails.root.join( *%w(app assets compiled_templates) << "#{relative_view_path}" )
+        
+        rabl_path               = Rails.root.join( 'app', 'views', relative_view_path, "#{view_name}.rabl" )
+        template_path           = File.join( template_partial_path, "#{view_name}.hbs" )
+        compiled_template_path  = File.join( compiled_template_partial_path, "#{view_name}.js" )
+        
+        FileUtils.mkdir_p template_partial_path             unless File.directory? template_partial_path
+        FileUtils.mkdir_p compiled_template_partial_path    unless File.directory? compiled_template_partial_path
+        
+        return rabl_path, template_path, compiled_template_path
+        
+      end
+    
+    end
+    
+  end
+        
+  class Runner
+    
+    def initialize(template, rendered_haml = nil, view_type, view_name, partial_name, relative_view_path, rabl_path, template_path, compiled_template_path)
+      @template                 = template
+      @rendered_haml            = rendered_haml
+      @view_type                = view_type
+      @view_name                = view_name
+      @partial_name             = partial_name
+      @relative_view_path       = relative_view_path
+      @rabl_path                = rabl_path
+      @template_path            = template_path
+      @compiled_template_path   = compiled_template_path
+    end
+    
+    def run
+      
+      content_cache = DryHamlHandlebars.content_cache
+      out = []
+    
+      if @rendered_haml
+      
+        out << @rendered_haml
+        out << compile_hbs
+        
+        case @view_type
+        when :template
+          
+          out << name_template
+          out << gen_template_loader
+          
+        when :partial
+          
+          out << name_partial
+          out << gen_partial_loader
+          
+        end
+
+        out << write_asset_files
+        out << get_hbs_context
+        out << load_template
+                  
+      else #if we don't have any rendered haml (we're probably in production)
+        
+        out << get_hbs_context
+        out << name_template
+        
+      end
+
+      out << set_locale if defined? SimplesIdeias::I18n
+
+      case @view_type
+      when :template
+        
+        out << render_rabl
+        out << set_gon_variable
+        
+        if content_cache.store.present? #do we need to render some content for another view?
+
+          content_cache.store.each do |item|
+            
+            name = item.name
+            path = item.path
+            content_cache.remove_item(item)
+            
+            #NOTE: this call will overwrite all eval'd variables set below, except for template_names
+            #we store this in a stack and pop the last name when we get to render_template()
+            #it doesn't matter about the other variables as we're finished with them by this stage
+            #and it keeps the eval code simpler if we just reuse them
+            
+            out << render_content_for(name, path)
+            
+          end
+          content_cache.clear #just to be sure
+          
+        end
+        
+        out << render_template
+        
+      when :partial
+        
+        out << render_handlebars_partial_command
+        
+      end
+      
+      out.join("\n")
+
+
+    end
+    
+    def compile_hbs
+      <<-RUBY
+        compiled_hbs = HandlebarsAssets::Handlebars.precompile( rendered_haml )
+      RUBY
+    end
+    
+    def name_template
+      <<-RUBY
+        template_names ||= []
+        template_names << '#{File.join(@relative_view_path, @view_name).to_s}'
+      RUBY
+    end
+    
+    def name_partial
+      <<-RUBY
+        partial_name  = '#{@partial_name}'
+      RUBY
+    end
+    
+    def gen_template_loader
+      <<-'RUBY'
+        hbs_loader = "(function() {
+          this.HandlebarsTemplates || (this.HandlebarsTemplates = {});
+          this.HandlebarsTemplates['#{template_names.last}'] = Handlebars.template(#{compiled_hbs});
+          return HandlebarsTemplates['#{template_names.last}'];
+        }).call(this)"
+      RUBY
+    end
+    
+    def gen_partial_loader
+      <<-'RUBY'
+        hbs_loader = "(function() {
+          this.Handlebars.registerPartial('#{partial_name}', Handlebars.template(#{compiled_hbs}));
+        }).call(this)"
+      RUBY
+    end
+    
+    def write_asset_files
+      <<-RUBY
+        File.open('#{@template_path}',          'w+') {|f| f.write(rendered_haml) }
+        File.open('#{@compiled_template_path}', 'w+') {|f| f.write(hbs_loader) }
+      RUBY
+    end
+    
+    def get_hbs_context
+      <<-RUBY
+        hbs_context = HandlebarsAssets::Handlebars.send(:context)
+      RUBY
+    end
+    
+    def set_locale
+      <<-RUBY
+        hbs_context.eval("I18n.locale = '#{I18n.locale.to_s}'")
+      RUBY
+    end
+    
+    def load_template
+      <<-RUBY
+        File.open('#{@compiled_template_path}') do |file|
+          hbs_context.eval(file.read, '#{@view_name}.js')
+        end
+      RUBY
+    end
+    
+    def render_rabl
+      
+      if File.exist? @rabl_path
+    
+        rabl_handler  = ActionView::Template.handler_for_extension :rabl
+        rabl_source   = File.read(@rabl_path)
+        rabl_template = ActionView::Template.new(rabl_source, @rabl_path, rabl_handler, {:locals => @template.locals})
+        rabl_call     = rabl_handler.call rabl_template
+
+        <<-RUBY
+          rabl_call_str = %q( #{rabl_call} )
+          rendered_rabl = eval(rabl_call_str).html_safe
+        RUBY
+        
+      else
+        
+        <<-RUBY
+          rendered_rabl ||= '{}'.html_safe
+        RUBY
+        
+      end
+      
+    end
+    
+    def set_gon_variable
+      <<-'RUBY'
+        Gon::Request.id  = request.object_id
+        Gon::Request.env = request.env
+        Gon.view_data  ||= JSON.parse(rendered_rabl)
+      RUBY
+    end
+    
+    def render_template
+      <<-'RUBY'
+        current_template_name = template_names.pop
+        hbs_context.eval( "HandlebarsTemplates['#{current_template_name}'](#{rendered_rabl})" )
+      RUBY
+    end
+    
+    def render_handlebars_partial_command
+      <<-RUBY
+        '{{> #{@partial_name}}}'.html_safe
+      RUBY
+    end
+    
+    def render_content_for(name, path)
+      
+      haml_handler  = ActionView::Template.handler_for_extension :haml
+      haml_source   = File.read(path)
+      haml_template = ActionView::Template.new(haml_source, path, haml_handler, {})
+      haml_call     = haml_handler.call haml_template
+
+      <<-RUBY
+        @view_flow.set( :#{name}, eval(%q( #{haml_call} )).html_safe )
+      RUBY
+      
+    end
+      
+    
+  end
+  
+end
+
+
+
+
+
+
+