handlebars_assets 0.8.1 → 0.23.9

data/lib/handlebars_assets/config.rb

@@ -2,56 +2,144 @@ module HandlebarsAssets
   # Change config options in an initializer:
   #
   # HandlebarsAssets::Config.path_prefix = 'app/templates'
+
   module Config
     extend self
 
-    attr_writer :compiler, :compiler_path, :ember, :haml_options, :known_helpers, :known_helpers_only, :options, :path_prefix, :template_namespace
+    attr_writer :compiler, :compiler_path, :ember, :multiple_frameworks,
+      :haml_options, :known_helpers, :known_helpers_only, :options,
+      :patch_files, :patch_path, :path_prefix, :slim_options, :template_namespace,
+      :precompile, :haml_enabled, :slim_enabled,
+      :handlebars_extensions, :hamlbars_extensions, :slimbars_extensions,
+      :amd, :handlebars_amd_path, :amd_with_template_namespace,
+      :chomp_underscore_for_partials
 
     def compiler
       @compiler || 'handlebars.js'
     end
 
+    def self.configure
+      yield self
+    end
+
     def compiler_path
       @compiler_path || HandlebarsAssets.path
     end
 
     def ember?
-      @ember
+      @ember || false
+    end
+
+    def multiple_frameworks?
+      @multiple_frameworks
     end
 
     def haml_available?
       defined? ::Haml::Engine
     end
 
+    def haml_enabled?
+      @haml_enabled = true if @haml_enabled.nil?
+      @haml_enabled
+    end
+
     def haml_options
       @haml_options || {}
     end
 
+    def slim_available?
+      defined? ::Slim::Engine
+    end
+
+    def slim_enabled?
+      @slim_enabled = true if @slim_enabled.nil?
+      @slim_enabled
+    end
+
+    def slim_options
+      @slim_options || {}
+    end
+
     def known_helpers
       @known_helpers || []
     end
 
     def known_helpers_only
-      @known_helpers_only || false
+      @known_helpers_only = false if @known_helpers_only.nil?
+      @known_helpers_only
     end
 
     def options
       @options ||= generate_options
     end
 
+    def patch_files
+      Array(@patch_files)
+    end
+
+    def patch_path
+      @patch_path ||= compiler_path
+    end
+
     def path_prefix
-      @path_prefix || 'templates'
+      @path_prefix ||= 'templates'
+    end
+
+    def precompile
+      @precompile = true if @precompile.nil?
+      @precompile
     end
 
     def template_namespace
       @template_namespace || 'HandlebarsTemplates'
     end
 
+    def handlebars_extensions
+      @hbs_extensions ||= ['.hbs', '.handlebars']
+    end
+
+    def hamlbars_extensions
+      @hamlbars_extensions ||= ['.hamlbars']
+    end
+
+    def slimbars_extensions
+      @slimbars_extensions ||= ['.slimbars']
+    end
+
+    def ember_extensions
+      @ember_extensions ||= ['.ember']
+    end
+
+    def amd?
+      @amd || false
+    end
+
+    # indicate whether the template should
+    # be added to the global template namespace
+    def amd_with_template_namespace
+      @amd_with_template_namespace || false
+    end
+
+    # path specified by the require.js paths
+    # during configuration for the handlebars
+    def handlebars_amd_path
+      @handlebars_amd_path || 'handlebars'
+    end
+
+    # Indicate if leading underscore should be allowed
+    # when creating partial definition.
+    # Allows compatibility with handlebars-rails
+    # https://github.com/cowboyd/handlebars-rails/blob/f73a2d11df8aa2c21d335b8f04a8c5b59ae6a790/lib/handlebars-rails/tilt.rb#L18
+    def chomp_underscore_for_partials?
+      @chomp_underscore_for_partials || false
+    end
+
     private
 
     def generate_known_helpers_hash
       known_helpers.inject({}) do |hash, helper|
         hash[helper] = true
+        hash
       end
     end
 

data/lib/handlebars_assets/engine.rb

@@ -1,10 +1,13 @@
 module HandlebarsAssets
+  # NOTE: must be an engine because we are including assets in the gem
   class Engine < ::Rails::Engine
-    initializer "sprockets.handlebars", :after => "sprockets.environment", :group => :all do |app|
-      next unless app.assets
-      app.assets.register_engine('.hbs', TiltHandlebars)
-      app.assets.register_engine('.handlebars', TiltHandlebars)
-      app.assets.register_engine('.hamlbars', TiltHandlebars) if HandlebarsAssets::Config.haml_available?
+    initializer "handlebars_assets.assets.register", :group => :all do |app|
+      app.config.assets.configure do |sprockets_env|
+        ::HandlebarsAssets::register_extensions(sprockets_env)
+        if Gem::Version.new(Sprockets::VERSION) < Gem::Version.new('3')
+          ::HandlebarsAssets::add_to_asset_versioning(sprockets_env)
+        end
+      end
     end
   end
 end

data/lib/handlebars_assets/handlebars.rb

@@ -5,18 +5,42 @@ require 'pathname'
 module HandlebarsAssets
   class Handlebars
     class << self
+
       def precompile(*args)
         context.call('Handlebars.precompile', *args)
       end
 
-      private
+      protected
+
+      attr_writer :source
+
+      def append_patch(patch_file)
+        self.source += patch_source(patch_file)
+      end
+
+      def apply_patches_to_source
+        if HandlebarsAssets::Config.patch_files.any?
+          HandlebarsAssets::Config.patch_files.each do |patch_file|
+            append_patch(patch_file)
+          end
+        end
+        source
+      end
 
       def context
-        @context ||= ExecJS.compile(source)
+        @context ||= ExecJS.compile(apply_patches_to_source)
       end
 
       def source
-        @source ||= path.read
+        @source ||= "if (!window) { var window = {}; }\n#{path.read}"
+      end
+
+      def patch_path
+        @patch_path ||= Pathname(HandlebarsAssets::Config.patch_path)
+      end
+
+      def patch_source(patch_file)
+        patch_path.join(patch_file).read
       end
 
       def path

data/lib/handlebars_assets/handlebars_template.rb

@@ -0,0 +1,267 @@
+require 'tilt'
+require 'json'
+
+module HandlebarsAssets
+  module Unindent
+    # http://bit.ly/aze9FV
+    # Strip leading whitespace from each line that is the same as the
+    # amount of whitespace on the first line of the string.
+    # Leaves _additional_ indentation on later lines intact.
+    def unindent(heredoc)
+      heredoc.gsub(/^#{heredoc[/\A\s*/]}/, '')
+    end
+  end
+
+  # Sprockets <= 3
+  class HandlebarsTemplate < Tilt::Template
+    def self.default_mime_type
+      'application/javascript'
+    end
+
+    def initialize_engine
+      HandlebarsRenderer.initialize_engine
+    end
+
+    def prepare
+      @engine = renderer.choose_engine(data)
+    end
+
+    def evaluate(scope, locals, &block)
+      source = @engine.render(scope, locals, &block)
+      renderer.compile(source)
+    end
+
+    private
+
+    def renderer
+      @renderer ||= HandlebarsRenderer.new(path: @file)
+    end
+  end
+
+  # Sprockets 4
+  class HandlebarsProcessor
+
+    def self.instance
+      @instance ||= new
+    end
+
+    def self.call(input)
+      instance.call(input)
+    end
+
+    def self.cache_key
+      instance.cache_key
+    end
+
+    attr_reader :cache_key
+
+    def initialize(options = {})
+      @cache_key = [self.class.name, ::HandlebarsAssets::VERSION, options].freeze
+    end
+
+    def call(input)
+      renderer = HandlebarsRenderer.new(path: input[:filename])
+      engine = renderer.choose_engine(input[:data])
+      renderer.compile(engine.render)
+    end
+  end
+
+  class NoOpEngine
+    def initialize(data)
+      @data = data
+    end
+
+    def render(*args)
+      @data
+    end
+  end
+
+  class HandlebarsRenderer
+    include Unindent
+
+    def self.initialize_engine
+      return if @initialized
+
+      begin
+        require 'haml'
+      rescue LoadError
+        # haml not available
+      end
+      begin
+        require 'slim'
+      rescue LoadError
+        # slim not available
+      end
+
+      @initialized = true
+    end
+
+    def initialize(options)
+      self.class.initialize_engine
+      @template_path = TemplatePath.new(options[:path])
+    end
+
+    def choose_engine(data)
+      if @template_path.is_haml?
+        Haml::Engine.new(data, HandlebarsAssets::Config.haml_options)
+      elsif @template_path.is_slim?
+        Slim::Template.new(HandlebarsAssets::Config.slim_options) { data }
+      else
+        NoOpEngine.new(data)
+      end
+    end
+
+    def compile(source)
+      # remove trailing \n on file, for some reason the directives pipeline adds this
+      source.chomp!($/)
+
+      # handle the case of multiple frameworks combined with ember
+      # DEFER: use extension setup for ember
+      if (HandlebarsAssets::Config.multiple_frameworks? && @template_path.is_ember?) ||
+         (HandlebarsAssets::Config.ember? && !HandlebarsAssets::Config.multiple_frameworks?)
+        compile_ember(source)
+      else
+        compile_default(source)
+      end
+    end
+
+    def compile_ember(source)
+      "window.Ember.TEMPLATES[#{@template_path.name}] = Ember.Handlebars.compile(#{JSON.dump(source)});"
+    end
+
+    def compile_default(source)
+      template =
+        if HandlebarsAssets::Config.precompile
+          compiled_hbs = Handlebars.precompile(source, HandlebarsAssets::Config.options)
+          "Handlebars.template(#{compiled_hbs})"
+        else
+          "Handlebars.compile(#{JSON.dump(source)})"
+        end
+
+      template_namespace = HandlebarsAssets::Config.template_namespace
+
+      if HandlebarsAssets::Config.amd?
+        handlebars_amd_path = HandlebarsAssets::Config.handlebars_amd_path
+        if HandlebarsAssets::Config.amd_with_template_namespace
+          if @template_path.is_partial?
+            unindent <<-PARTIAL
+              define(['#{handlebars_amd_path}'],function(Handlebars){
+                var t = #{template};
+                Handlebars.registerPartial(#{@template_path.name}, t);
+                return t;
+              ;})
+            PARTIAL
+          else
+            unindent <<-TEMPLATE
+              define(['#{handlebars_amd_path}'],function(Handlebars){
+                return #{template};
+              });
+            TEMPLATE
+          end
+        else
+          if @template_path.is_partial?
+            unindent <<-PARTIAL
+              define(['#{handlebars_amd_path}'],function(Handlebars){
+                var t = #{template};
+                Handlebars.registerPartial(#{@template_path.name}, t);
+                return t;
+              ;})
+            PARTIAL
+          else
+            unindent <<-TEMPLATE
+              define(['#{handlebars_amd_path}'],function(Handlebars){
+                this.#{template_namespace} || (this.#{template_namespace} = {});
+                this.#{template_namespace}[#{@template_path.name}] = #{template};
+                return this.#{template_namespace}[#{@template_path.name}];
+              });
+            TEMPLATE
+          end
+        end
+      else
+        if @template_path.is_partial?
+          unindent <<-PARTIAL
+            (function() {
+              Handlebars.registerPartial(#{@template_path.name}, #{template});
+            }).call(this);
+          PARTIAL
+        else
+          unindent <<-TEMPLATE
+            (function() {
+              this.#{template_namespace} || (this.#{template_namespace} = {});
+              this.#{template_namespace}[#{@template_path.name}] = #{template};
+              return this.#{template_namespace}[#{@template_path.name}];
+            }).call(this);
+          TEMPLATE
+        end
+      end
+    end
+
+    protected
+
+    class TemplatePath
+      def initialize(path)
+        @full_path = path
+      end
+
+      def check_extension(ext)
+        result = false
+        if ext.start_with? '.'
+          ext = "\\#{ext}"
+          result ||= !(@full_path =~ /#{ext}(\..*)*$/).nil?
+        else
+          result ||= !(@full_path =~ /\.#{ext}(\..*)*$/).nil?
+        end
+        result
+      end
+
+      def is_haml?
+        result = false
+        ::HandlebarsAssets::Config.hamlbars_extensions.each do |ext|
+          result ||= check_extension(ext)
+        end
+        result
+      end
+
+      def is_slim?
+        result = false
+        ::HandlebarsAssets::Config.slimbars_extensions.each do |ext|
+          result ||= check_extension(ext)
+        end
+        result
+      end
+
+      def is_ember?
+        result = false
+        ::HandlebarsAssets::Config.ember_extensions.each do |ext|
+          result ||= check_extension(ext)
+        end
+        result
+      end
+
+      def is_partial?
+        @full_path.gsub(%r{.*/}, '').start_with?('_')
+      end
+
+      def name
+        template_name
+      end
+
+      private
+
+      def relative_path
+        path = @full_path.match(/.*#{HandlebarsAssets::Config.path_prefix}\/((.*\/)*([^.]*)).*$/)[1]
+        if is_partial? && ::HandlebarsAssets::Config.chomp_underscore_for_partials?
+          #handle case if partial is in root level of template folder
+          path.gsub!(%r~^_~, '')
+          #handle case if partial is in a subfolder within the template folder
+          path.gsub!(%r~/_~, '/')
+        end
+        path
+      end
+
+      def template_name
+        relative_path.dump
+      end
+    end
+  end
+end

data/lib/handlebars_assets/version.rb

@@ -1,3 +1,3 @@
 module HandlebarsAssets
-  VERSION = "0.8.1"
+  VERSION = "0.23.9"
 end

data/lib/handlebars_assets.rb

@@ -1,21 +1,58 @@
-require "handlebars_assets/version"
+require 'handlebars_assets/version'
 
 module HandlebarsAssets
-  PATH = File.expand_path("../../vendor/assets/javascripts", __FILE__)
+  autoload(:Config, 'handlebars_assets/config')
+  autoload(:Handlebars, 'handlebars_assets/handlebars')
+  autoload(:HandlebarsTemplate, 'handlebars_assets/handlebars_template')
+  autoload(:HandlebarsProcessor, 'handlebars_assets/handlebars_template')
+
+  PATH = File.expand_path('../../vendor/assets/javascripts', __FILE__)
 
   def self.path
     PATH
   end
 
-  autoload(:Config, 'handlebars_assets/config')
-  autoload(:Handlebars, 'handlebars_assets/handlebars')
-  autoload(:TiltHandlebars, 'handlebars_assets/tilt_handlebars')
+  def self.configure
+    yield Config
+  end
+
+  def self.register_extensions(sprockets_environment)
+    if Gem::Version.new(Sprockets::VERSION) < Gem::Version.new('3')
+      Config.handlebars_extensions.each do |ext|
+        sprockets_environment.register_engine(ext, HandlebarsTemplate)
+      end
+      if Config.haml_enabled? && Config.haml_available?
+        Config.hamlbars_extensions.each do |ext|
+          sprockets_environment.register_engine(ext, HandlebarsTemplate)
+        end
+      end
+      if Config.slim_enabled? && Config.slim_available?
+        Config.slimbars_extensions.each do |ext|
+          sprockets_environment.register_engine(ext, HandlebarsTemplate)
+        end
+      end
+    else
+      sprockets_environment.register_mime_type 'text/x-handlebars-template', extensions: Config.handlebars_extensions
+      if Config.slim_enabled? && Config.slim_available?
+        sprockets_environment.register_mime_type 'text/x-handlebars-template', extensions: Config.slimbars_extensions
+      end
+      if Config.haml_enabled? && Config.haml_available?
+        sprockets_environment.register_mime_type 'text/x-handlebars-template', extensions: Config.hamlbars_extensions
+      end
+      sprockets_environment.register_transformer 'text/x-handlebars-template', 'application/javascript', HandlebarsProcessor
+    end
+  end
 
-  if defined?(Rails) && defined?(::Rails::Engine)
-    require 'handlebars_assets/engine'
-  else
-    require 'sprockets'
-    Sprockets.register_engine '.hbs', TiltHandlebars
-    Sprockets.register_engine '.handlebars', TiltHandlebars
+  def self.add_to_asset_versioning(sprockets_environment)
+    sprockets_environment.version += "-#{HandlebarsAssets::VERSION}"
   end
 end
+
+# Register the engine (which will register extension in the app)
+# or ASSUME using sprockets
+if defined?(Rails)
+  require 'handlebars_assets/engine'
+else
+  require 'sprockets'
+  ::HandlebarsAssets.register_extensions(Sprockets)
+end