tilt 1.4.1 → 2.0.11

data/lib/tilt/template.rb

@@ -1,5 +1,19 @@
+require 'thread'
+
 module Tilt
-  TOPOBJECT = Object.superclass || Object
+  # @private
+  TOPOBJECT = if RUBY_VERSION >= '2.0'
+    # @private
+    module CompiledTemplates
+      self
+    end
+  elsif RUBY_VERSION >= '1.9'
+    BasicObject
+  else
+    Object
+  end
+  # @private
+  LOCK = Mutex.new
 
   # Base class for template implementations. Subclasses must implement
   # the #prepare method and one of the #evaluate or #precompiled_template
@@ -19,14 +33,22 @@ module Tilt
     # interface.
     attr_reader :options
 
-    # Used to determine if this class's initialize_engine method has
-    # been called yet.
-    @engine_initialized = false
     class << self
-      attr_accessor :engine_initialized
-      alias engine_initialized? engine_initialized
+      # An empty Hash that the template engine can populate with various
+      # metadata.
+      def metadata
+        @metadata ||= {}
+      end
+
+      # @deprecated Use `.metadata[:mime_type]` instead.
+      def default_mime_type
+        metadata[:mime_type]
+      end
 
-      attr_accessor :default_mime_type
+      # @deprecated Use `.metadata[:mime_type] = val` instead.
+      def default_mime_type=(value)
+        metadata[:mime_type] = value
+      end
     end
 
     # Create a new template with the file, line, and options specified. By
@@ -44,19 +66,14 @@ module Tilt
         when arg.respond_to?(:to_int)  ; @line = arg.to_int
         when arg.respond_to?(:to_hash) ; @options = arg.to_hash.dup
         when arg.respond_to?(:path)    ; @file = arg.path
-        else raise TypeError
+        when arg.respond_to?(:to_path) ; @file = arg.to_path
+        else raise TypeError, "Can't load the template file. Pass a string with a path " +
+          "or an object that responds to 'to_str', 'path' or 'to_path'"
         end
       end
 
       raise ArgumentError, "file or block required" if (@file || block).nil?
 
-      # call the initialize_engine method if this is the very first time
-      # an instance of this class has been created.
-      if !self.class.engine_initialized?
-        initialize_engine
-        self.class.engine_initialized = true
-      end
-
       # used to hold compiled template methods
       @compiled_method = {}
 
@@ -69,7 +86,10 @@ module Tilt
       @data = @reader.call(self)
 
       if @data.respond_to?(:force_encoding)
-        @data.force_encoding(default_encoding) if default_encoding
+        if default_encoding
+          @data = @data.dup if @data.frozen?
+          @data.force_encoding(default_encoding)
+        end
 
         if !@data.valid_encoding?
           raise Encoding::InvalidByteSequenceError, "#{eval_file} is not valid #{@data.encoding}"
@@ -79,28 +99,16 @@ module Tilt
       prepare
     end
 
-    # The encoding of the source data. Defaults to the
-    # default_encoding-option if present. You may override this method
-    # in your template class if you have a better hint of the data's
-    # encoding.
-    def default_encoding
-      @default_encoding
-    end
-
-    def read_template_file
-      data = File.open(file, 'rb') { |io| io.read }
-      if data.respond_to?(:force_encoding)
-        # Set it to the default external (without verifying)
-        data.force_encoding(Encoding.default_external) if Encoding.default_external
-      end
-      data
-    end
-
     # Render the template in the given scope with the locals specified. If a
     # block is given, it is typically available within the template via
     # +yield+.
-    def render(scope=Object.new, locals={}, &block)
-      evaluate scope, locals || {}, &block
+    def render(scope=nil, locals={}, &block)
+      scope ||= Object.new
+      current_template = Thread.current[:tilt_current_template]
+      Thread.current[:tilt_current_template] = self
+      evaluate(scope, locals || {}, &block)
+    ensure
+      Thread.current[:tilt_current_template] = current_template
     end
 
     # The basename of the template file.
@@ -118,30 +126,26 @@ module Tilt
       file || '(__TEMPLATE__)'
     end
 
-    # Whether or not this template engine allows executing Ruby script
-    # within the template. If this is false, +scope+ and +locals+ will
-    # generally not be used, nor will the provided block be avaiable 
-    # via +yield+.
-    # This should be overridden by template subclasses.
-    def allows_script?
-      true
+    # An empty Hash that the template engine can populate with various
+    # metadata.
+    def metadata
+      if respond_to?(:allows_script?)
+        self.class.metadata.merge(:allows_script => allows_script?)
+      else
+        self.class.metadata
+      end
     end
 
-  protected
-    # Called once and only once for each template subclass the first time
-    # the template class is initialized. This should be used to require the
-    # underlying template library and perform any initial setup.
-    def initialize_engine
-    end
+    protected
 
-    # Like Kernel#require but issues a warning urging a manual require when
-    # running under a threaded environment.
-    def require_template_library(name)
-      if Thread.list.size > 1
-        warn "WARN: tilt autoloading '#{name}' in a non thread-safe way; " +
-             "explicit require '#{name}' suggested."
-      end
-      require name
+    # @!group For template implementations
+
+    # The encoding of the source data. Defaults to the
+    # default_encoding-option if present. You may override this method
+    # in your template class if you have a better hint of the data's
+    # encoding.
+    def default_encoding
+      @default_encoding
     end
 
     # Do whatever preparation is necessary to setup the underlying template
@@ -150,15 +154,11 @@ module Tilt
     #
     # Subclasses must provide an implementation of this method.
     def prepare
-      if respond_to?(:compile!)
-        # backward compat with tilt < 0.6; just in case
-        warn 'Tilt::Template#compile! is deprecated; implement #prepare instead.'
-        compile!
-      else
-        raise NotImplementedError
-      end
+      raise NotImplementedError
     end
 
+    CLASS_METHOD = Kernel.instance_method(:class)
+
     # Execute the compiled template and return the result string. Template
     # evaluation is guaranteed to be performed in the scope object with the
     # locals specified and with support for yielding to the block.
@@ -166,7 +166,18 @@ module Tilt
     # This method is only used by source generating templates. Subclasses that
     # override render() may not support all features.
     def evaluate(scope, locals, &block)
-      method = compiled_method(locals.keys)
+      locals_keys = locals.keys
+      locals_keys.sort!{|x, y| x.to_s <=> y.to_s}
+      case scope
+      when Object
+        method = compiled_method(locals_keys, Module === scope ? scope : scope.class)
+      else
+        if RUBY_VERSION >= '2'
+          method = compiled_method(locals_keys, CLASS_METHOD.bind(scope).call)
+        else
+          method = compiled_method(locals_keys, Object)
+        end
+      end
       method.bind(scope).call(locals, &block)
     end
 
@@ -179,11 +190,11 @@ module Tilt
     # control over source generation or want to adjust the default line
     # offset. In most cases, overriding the #precompiled_template method is
     # easier and more appropriate.
-    def precompiled(locals)
-      preamble = precompiled_preamble(locals)
-      template = precompiled_template(locals)
-      postamble = precompiled_postamble(locals)
-      source = ''
+    def precompiled(local_keys)
+      preamble = precompiled_preamble(local_keys)
+      template = precompiled_template(local_keys)
+      postamble = precompiled_postamble(local_keys)
+      source = String.new
 
       # Ensure that our generated source code has the same encoding as the
       # the source code generated by the template engine.
@@ -194,10 +205,7 @@ module Tilt
         template.force_encoding(template_encoding)
       end
 
-      # https://github.com/rtomayko/tilt/issues/193
-      warn "precompiled_preamble should return String (not Array)" if preamble.is_a?(Array)
-      warn "precompiled_postamble should return String (not Array)" if postamble.is_a?(Array)
-      source << [preamble, template, postamble].join("\n")
+      source << preamble << "\n" << template << "\n" << postamble
 
       [source, preamble.count("\n")+1]
     end
@@ -208,17 +216,40 @@ module Tilt
     # the base Template guarantees correct file/line handling, locals
     # support, custom scopes, proper encoding, and support for template
     # compilation.
-    def precompiled_template(locals)
+    def precompiled_template(local_keys)
       raise NotImplementedError
     end
 
-    # Generates preamble code for initializing template state, and performing
-    # locals assignment. The default implementation performs locals
-    # assignment only. Lines included in the preamble are subtracted from the
-    # source line offset, so adding code to the preamble does not effect line
-    # reporting in Kernel::caller and backtraces.
-    def precompiled_preamble(locals)
-      locals.map do |k,v|
+    def precompiled_preamble(local_keys)
+      ''
+    end
+
+    def precompiled_postamble(local_keys)
+      ''
+    end
+
+    # !@endgroup
+
+    private
+
+    def read_template_file
+      data = File.open(file, 'rb') { |io| io.read }
+      if data.respond_to?(:force_encoding)
+        # Set it to the default external (without verifying)
+        data.force_encoding(Encoding.default_external) if Encoding.default_external
+      end
+      data
+    end
+
+    # The compiled method for the locals keys provided.
+    def compiled_method(locals_keys, scope_class=nil)
+      LOCK.synchronize do
+        @compiled_method[[scope_class, locals_keys]] ||= compile_template_method(locals_keys, scope_class)
+      end
+    end
+
+    def local_extraction(local_keys)
+      local_keys.map do |k|
         if k.to_s =~ /\A[a-z_][a-zA-Z_0-9]*\z/
           "#{k} = locals[#{k.inspect}]"
         else
@@ -227,41 +258,26 @@ module Tilt
       end.join("\n")
     end
 
-    # Generates postamble code for the precompiled template source. The
-    # string returned from this method is appended to the precompiled
-    # template source.
-    def precompiled_postamble(locals)
-      ''
-    end
-
-    # The compiled method for the locals keys provided.
-    def compiled_method(locals_keys)
-      @compiled_method[locals_keys] ||=
-        compile_template_method(locals_keys)
-    end
+    def compile_template_method(local_keys, scope_class=nil)
+      source, offset = precompiled(local_keys)
+      local_code = local_extraction(local_keys)
 
-  private
-    def compile_template_method(locals)
-      source, offset = precompiled(locals)
       method_name = "__tilt_#{Thread.current.object_id.abs}"
-      method_source = ""
+      method_source = String.new
 
       if method_source.respond_to?(:force_encoding)
-        method_source.force_encoding(source.encoding) 
+        method_source.force_encoding(source.encoding)
       end
 
       method_source << <<-RUBY
         TOPOBJECT.class_eval do
           def #{method_name}(locals)
-            Thread.current[:tilt_vars] = [self, locals]
-            class << self
-              this, locals = Thread.current[:tilt_vars]
-              this.instance_eval do
+            #{local_code}
       RUBY
       offset += method_source.count("\n")
       method_source << source
-      method_source << "\nend;end;end;end"
-      Object.class_eval method_source, eval_file, line - offset
+      method_source << "\nend;end;"
+      (scope_class || Object).class_eval(method_source, eval_file, line - offset)
       unbind_compiled_method(method_name)
     end
 
@@ -276,7 +292,7 @@ module Tilt
     end
 
     def extract_magic_comment(script)
-      binary script do
+      binary(script) do
         script[/\A[ \t]*\#.*coding\s*[=:]\s*([[:alnum:]\-_]+).*$/n, 1]
       end
     end

data/lib/tilt/typescript.rb

@@ -0,0 +1,26 @@
+require 'tilt/template'
+require 'typescript-node'
+
+module Tilt
+  class TypeScriptTemplate < Template
+    self.default_mime_type = 'application/javascript'
+
+    def prepare
+      @option_args = []
+
+      options.each do |key, value|
+        next unless value
+
+        @option_args << "--#{key}"
+
+        if value != true
+          @option_args << value.to_s
+        end
+      end
+    end
+
+    def evaluate(scope, locals, &block)
+      @output ||= TypeScript::Node.compile(data, *@option_args)
+    end
+  end
+end

data/lib/tilt/wikicloth.rb

@@ -0,0 +1,22 @@
+require 'tilt/template'
+require 'wikicloth'
+
+module Tilt
+  # WikiCloth implementation. See:
+  # http://redcloth.org/
+  class WikiClothTemplate < Template
+    def prepare
+      @parser = options.delete(:parser) || WikiCloth::Parser
+      @engine = @parser.new options.merge(:data => data)
+      @output = nil
+    end
+
+    def evaluate(scope, locals, &block)
+      @output ||= @engine.to_html
+    end
+
+    def allows_script?
+      false
+    end
+  end
+end

data/lib/tilt/yajl.rb

@@ -1,4 +1,5 @@
 require 'tilt/template'
+require 'yajl'
 
 module Tilt
 
@@ -42,14 +43,6 @@ module Tilt
 
     self.default_mime_type = 'application/json'
 
-    def self.engine_initialized?
-      defined? ::Yajl
-    end
-
-    def initialize_engine
-      require_template_library 'yajl'
-    end
-
     def prepare
     end