stache 0.2.2 → 0.9.0

data/CHANGELOG.md

@@ -1,3 +1,13 @@
+# 0.9.0
+
+/!\ /!\ Breaking Changes.
+
+* 1.0 release candidate
+* Handlebars support
+* uses Rails' own template resolution system to find partials.
+
+There's some code duplication that should be crushed out before 1.0.
+
 # 0.2.2
 
 * Saner, consistent handling of template extensions: partials and full templates both use configured value at `Stache.template_extension`. Thanks @ajacksified!

data/README.md

@@ -1,9 +1,16 @@
 # stache
 
-A Rails 3.x compatible Mustache Template Handler, with support for partials and a couple extra niceties to make sharing the raw templates with client-side javascript a little easier.
+A Rails 3.x compatible Mustache/Handlebars Template Handler, with support for partials and a couple extra niceties to make sharing the raw templates with client-side javascript a little easier. It's a one-stop shop for your facial-hair-inspired templates.
+
+[![Build Status](https://secure.travis-ci.org/agoragames/stache.png)](http://travis-ci.org/agoragames/stache)
+
+## Notice Of Breaking Changes
+
+Stache 0.9.x adds handlebars support. In the process, the public API has changed *ever-so-slightly*. Specifically, you'll need to require the mustache or handlebars gems on your own, **and** you'll need to tell Stache which one (or both!) you want to use. Add `config.use :mustache` to your initializer.
 
 ## Usage
 
+    gem "mustache" # or "handlebars"
     gem "stache"
 
 Install the gem. If you want to override any of the configuration options (see `stache/config`), toss an initializer in `config/initializers` and:
@@ -12,23 +19,28 @@ Install the gem. If you want to override any of the configuration options (see `
 Stache.configure do |c|
   c.template_base_path = "..."  # this is probably the one you'll want to change
                                 # it defaults to app/templates
+
+  # N.B. YOU MUST TELL STACHE WHICH TO USE:
+  c.use :mustache
+  # and / or
+  c.use :handlebars
 end
 
 # or if the block style ain't yer thang, just:
 Stache.template_base_path = File.join(Rails.root, "app", "şablon")
 ```
 
-There is as of right now one provided helper, `template_include_tag`. Give it the name of a partial and it will write it raw to a script block. On the todo list is the ability to customize this helper a little more :).
+There is as of right now one provided helper, `template_include_tag`. Give it the name of a partial and it will write it raw to a script block.
 
 ## A View Class of your Very Own
 
-To facilitate easy integration, 'Stache comes packaged with a fully-functioning subclass of Mustache, called `Stache::View`. It will try to find a more appropriate view class to provide to the template renderer based on the template name, but if one cannot be found it will automatically give ya a `Stache::View` so you can have *something*.
+To facilitate easy integration, 'Stache comes packaged with a fully-functioning subclass of Mustache, called `Stache::Mustache::View`. It will try to find a more appropriate view class to provide to the template renderer based on the template name, but if one cannot be found it will automatically give ya a `Stache::Mustache::View` so you can have *something*.
 
-Needless to say, it's probably better if your custom View objects are subclasses of `Stache::View`. That way we can all be sure that the handler will render correctly.
+Needless to say, it's probably better if your custom View objects are subclasses of `Stache::Mustache::View`. That way we can all be sure that the handler will render correctly.
 
 An example by way of explanation:
 
-With a template `app/templates/profiles/index`, Stache will look for a view named `Profiles::Index`, and, if not found, will just use the base `Stache::View`. Stache adds `app/views` to Rails' autoload paths, so here's a sample directory structure and some sample files:
+With a template `app/templates/profiles/index`, Stache will look for a view named `Profiles::Index`, and, if not found, will just use the base `Stache::Mustache::View`. Stache adds `app/views` to Rails' autoload paths, so here's a sample directory structure and some sample files:
 
 ```
 app/
@@ -43,7 +55,7 @@ app/
 ```ruby
 # in profiles/index.rb
 module Profiles
-  class Index < ::Stache::View
+  class Index < ::Stache::Mustache::View
     def my_view_helper_method
       "whoo"
     end
@@ -56,6 +68,16 @@ end
 <p>Here's a helper_method call: {{ my_view_helper_method }}</p>
 ```
 
+### Handlebars?
+
+Handlebars will have full access to your rails view helpers.
+
+```
+I'm a handlebars template. Look at me call a helper: {{{image_path my_image}}}
+```
+
+You can subclass `Stache::Handlebars::View` in the same way as mustache above, but there isn't as much point in doing so.
+
 ## Of Note
 
 This is code that was ripped out of a research project. It probably has some rough edges.
@@ -73,15 +95,18 @@ This project builds on work done by the following people and projects:
 * olivernn's [Poirot](https://github.com/olivernn/poirot)
 * goodmike's [mustache_rails3](https://github.com/goodmike/mustache_rails3)
 * nex3's [HAML](https://github.com/nex3/haml)
+* cowboyd's [handlebars.rb](https://github.com/cowboyd/handlebars.rb)
 
 So: thanks a ton to those guys.
 
 ## Contributors
 
 * [afeld](https://github.com/afeld) provided 1.8.7 compatibility fixes.
-* [subwindow](https://github.com/subwindow) provided some much needed love for Stache::View exception handling.
+* [subwindow](https://github.com/subwindow) provided some much needed love for Stache::Mustache::View exception handling.
 * [solotimes](https://github.com/solotimes) provided better support for non-standard encodings.
 * [ajacksified](https://github.com/ajacksified) cleaned up template extension handling.
+* [ayamomiji](https://github.com/ayamomiji) extended the `#template_include_tag` to pass through the full range of `#content_tag` options.
+* [awestendorf](https://github.com/awestendorf) requested that `View#partial` not be so particular about leading underscores. Though I didn't use his code, his prompt lead me to investigate how to properly use Rails' internal template lookup code.
 
 ## Note on Patches/Pull Requests
 

data/lib/stache.rb

@@ -1,7 +1,6 @@
 require "stache/version"
 require "stache/config"
 require "stache/util"
-require "stache/handler"
 require "stache/asset_helper"
 
 if defined? ::Rails::Railtie and ::Rails::VERSION::MAJOR >= 3
@@ -10,8 +9,7 @@ end
 
 module Stache
   extend Config
-  
+
 end
 
-ActionView::Template.register_template_handler(:mustache, Stache::Handler)
 ActionView::Base.send :include, Stache::AssetHelper

data/lib/stache/asset_helper.rb

@@ -3,31 +3,24 @@ module Stache
     # template_include_tag("widgets/basic_text_api_data")
     # template_include_tag("shared/test_thing")
     def template_include_tag(*sources)
+      options = sources.extract_options!
       sources.collect do |source|
-        exploded = source.split("/")
-        file = exploded.pop
-        file = file.split(".").first
-
-        base_path = Stache.template_base_path.join(*exploded)
-        template_path = locate_template_for(base_path, file)
-        if template_path
-          template = ::File.open(template_path, "rb" , :encoding => Rails.configuration.encoding)
-          content_tag(:script, template.read.html_safe, :type => "text/html", :id => "#{file.dasherize.underscore}_template")
-        else
-          raise ActionView::MissingTemplate.new(potential_paths(base_path, file), file, [base_path], false, { :handlers => [:mustache] })
+        template_finder = lambda do |partial|
+          if ActionPack::VERSION::MAJOR == 3 && ActionPack::VERSION::MINOR < 2
+            lookup_context.find(source, [], partial)
+          else # Rails 3.2 and higher
+            lookup_context.find(source, [], partial, [], { formats: [:html] })
+          end
         end
+
+        template = template_finder.call(true) rescue template_finder.call(false)
+        template_id = source.split("/").last
+
+        options = options.reverse_merge(:type => "text/html", :id => "#{template_id.dasherize.underscore}_template")
+        content_tag(:script, template.source.html_safe, options)
+
       end.join("\n").html_safe
     end
-    
-    def potential_paths(path, candidate_file_name)
-      [
-        path.join("_#{candidate_file_name}.#{Stache.template_extension}"),
-        path.join("#{candidate_file_name}.#{Stache.template_extension}")
-      ]
-    end
-    
-    def locate_template_for(path, candidate_file_name)
-      potential_paths(path, candidate_file_name).find { |file| File.file?(file.to_s) }
-    end
+
   end
 end

data/lib/stache/config.rb

@@ -7,29 +7,31 @@ module Stache
   #
   # Stache.configure do |config|
   #   config.template_base_path = Rails.root.join('app', 'views', 'shared')
+  #
+  #   use :mustache # or :handlebars
   # end
   module Config
-    attr_accessor :template_base_path, :template_extension, :shared_path
-    
+    attr_accessor :template_base_path, :shared_path
+
     def configure
       yield self
     end
-    
-    
+
+
     def template_base_path
       @template_base_path ||= ::Rails.root.join('app', 'templates')
     end
-    
+
     def template_base_path= path
       @template_base_path = Pathname.new(path)
     end
 
-    def template_extension
-      @template_extension ||= 'html.mustache'
-    end
-
     def shared_path
       @shared_path ||= ::Rails.root.join('app', 'templates', 'shared')
     end
+
+    def use template_engine
+      require "stache/#{template_engine}"
+    end
   end
 end

data/lib/stache/handlebars.rb

@@ -0,0 +1,7 @@
+require "stache/handlebars/handler"
+
+module Stache
+  module Handlebars; end
+end
+
+ActionView::Template.register_template_handler :hbs, Stache::Handlebars::Handler

data/lib/stache/handlebars/handler.rb

@@ -0,0 +1,80 @@
+require 'stache/handlebars/view'
+
+module Stache
+  module Handlebars
+    # From HAML, thanks a bunch, guys!
+    # In Rails 3.1+, template handlers don't inherit from anything. In <= 3.0, they do.
+    # To avoid messy logic figuring this out, we just inherit from whatever the ERB handler does.
+    class Handler < Stache::Util.av_template_class(:Handlers)::ERB.superclass
+      if Stache::Util.needs_compilable?
+        include Stache::Util.av_template_class(:Handlers)::Compilable
+      end
+
+      def compile(template)
+        handlebars_class = handlebars_class_from_template(template)
+
+        <<-RUBY_CODE
+          handlebars = ::#{handlebars_class}.new
+
+          handlebars.register_helper('helperMissing') do |name, *args|
+            meth, *params, options = args
+            if self.respond_to?(meth)
+              self.send(meth, *params)
+            else
+              raise "Could not find property '\#\{meth\}'"
+            end
+          end
+
+          template = handlebars.compile('#{template.source.gsub(/'/, "\\\\'")}');
+          vars = {}
+          partial_renderer = @view_renderer.send(:_partial_renderer)
+          vars.merge!(@_assigns)
+          vars.merge!(partial_renderer.instance_variable_get('@locals') || {})
+          options = partial_renderer.instance_variable_get('@options')
+          vars.merge!(options[:context] || {}) if options
+
+          Rails.logger.info vars.inspect
+
+          handlebars.partial_missing do |name|
+            search_path = '#{template.virtual_path}'.split("/")[0..-2]
+            file = (search_path + [name]).join("/")
+            finder = lambda do |partial|
+              self.lookup_context.find(file, [], partial, [], {:formats => [:html]})
+            end
+            template = finder.call(false) rescue finder.call(true)
+
+            if template
+              t = handlebars.compile(template.source)
+              t.call(vars).html_safe
+            else
+              raise "Could not find template '\#\{file\}'"
+            end
+          end
+
+          template.call(vars).html_safe
+        RUBY_CODE
+      end
+
+      # In Rails 3.1+, #call takes the place of #compile
+      def self.call(template)
+        new.compile(template)
+      end
+
+      # suss out a constant name for the given template
+      def handlebars_class_from_template(template)
+        const_name = ActiveSupport::Inflector.camelize(template.virtual_path.to_s)
+        begin
+          const_name.constantize
+        rescue NameError, LoadError => e
+          # Only rescue NameError/LoadError concerning our mustache_class
+          if e.message.match(/#{const_name}$/)
+            Stache::Handlebars::View
+          else
+            raise e
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/stache/handlebars/view.rb

@@ -0,0 +1,14 @@
+require 'handlebars'
+
+module Stache
+  module Handlebars
+    #
+    # A Convienent Base Class for the views. Subclass this for autoloading magic with your templates.
+    class View < ::Handlebars::Context
+
+      # crickets. So, this isn't as useful right now since you have to call #register_helper
+      # and #partial_missing on the instance, but I'm sure we'll find a use for it :).
+
+    end
+  end
+end

data/lib/stache/mustache.rb

@@ -0,0 +1,7 @@
+require "stache/mustache/handler"
+
+module Stache
+  module Mustache; end
+end
+
+ActionView::Template.register_template_handler :mustache, Stache::Mustache::Handler

data/lib/stache/mustache/handler.rb

@@ -0,0 +1,70 @@
+require 'stache/mustache/view'
+
+module Stache
+  module Mustache
+    # From HAML, thanks a bunch, guys!
+    # In Rails 3.1+, template handlers don't inherit from anything. In <= 3.0, they do.
+    # To avoid messy logic figuring this out, we just inherit from whatever the ERB handler does.
+    class Handler < Stache::Util.av_template_class(:Handlers)::ERB.superclass
+      if Stache::Util.needs_compilable?
+        include Stache::Util.av_template_class(:Handlers)::Compilable
+      end
+
+      # Thanks to Mustache::Rails3 for getting us most of the way home here
+      def compile(template)
+        #
+        # get a custom Mustache, or the default Stache::Mustache::View
+        mustache_class = mustache_class_from_template(template)
+
+        # Return a string that will be eval'd in the context of the ActionView, ugly, but it works.
+        <<-MUSTACHE
+          mustache = ::#{mustache_class}.new
+          mustache.view = self
+          mustache.template = '#{template.source.gsub(/'/, "\\\\'")}'
+          mustache.virtual_path = '#{template.virtual_path.to_s}'
+          mustache[:yield] = content_for(:layout)
+          mustache.context.update(local_assigns)
+          variables = controller.instance_variable_names
+          variables -= %w[@template]
+
+          if controller.respond_to?(:protected_instance_variables)
+            variables -= controller.protected_instance_variables
+          end
+
+          variables.each do |name|
+            mustache.instance_variable_set(name, controller.instance_variable_get(name))
+          end
+
+          # Declaring an +attr_reader+ for each instance variable in the
+          # Stache::Mustache::View subclass makes them available to your templates.
+          mustache.class.class_eval do
+            attr_reader *variables.map { |name| name.sub(/^@/, '').to_sym }
+          end
+
+          mustache.render.html_safe
+        MUSTACHE
+      end
+
+      # In Rails 3.1+, #call takes the place of #compile
+      def self.call(template)
+        new.compile(template)
+      end
+
+      # suss out a constant name for the given template
+      def mustache_class_from_template(template)
+        const_name = ActiveSupport::Inflector.camelize(template.virtual_path.to_s)
+        begin
+          const_name.constantize
+        rescue NameError, LoadError => e
+          # Only rescue NameError/LoadError concerning our mustache_class
+          if e.message.match(/#{const_name}$/)
+            Stache::Mustache::View
+          else
+            raise e
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/stache/mustache/view.rb

@@ -0,0 +1,37 @@
+require 'mustache'
+
+module Stache
+  module Mustache
+    #
+    # A Convienent Base Class for the views. Subclass this for autoloading magic with your templates.
+    class View < ::Mustache
+      attr_accessor :view, :template, :virtual_path
+
+      def method_missing(method, *args, &block)
+        view.send(method, *args, &block)
+      end
+
+      def respond_to?(method, include_private=false)
+        super(method, include_private) || view.respond_to?(method, include_private)
+      end
+
+      # Redefine where Stache::View templates locate their partials
+      def partial(name)
+        current_dir = Stache.template_base_path.join( self.virtual_path.split("/")[0..-2].join("/") )
+        lookup_context.view_paths += [current_dir]
+
+        template_finder = lambda do |partial|
+          if ActionPack::VERSION::MAJOR == 3 && ActionPack::VERSION::MINOR < 2
+            lookup_context.find(name, [], partial)
+          else # Rails 3.2 and higher
+            lookup_context.find(name, [], partial, [], { formats: [:html], handlers: [:mustache] })
+          end
+        end
+
+        template = template_finder.call(true) rescue template_finder.call(false)
+        template.source
+      end
+
+    end
+  end
+end

data/lib/stache/version.rb

@@ -1,3 +1,3 @@
 module Stache
-  VERSION = "0.2.2"
+  VERSION = "0.9.0"
 end