tilt 2.0.11 → 2.3.0

data/lib/tilt/csv.rb

@@ -1,10 +1,6 @@
-require 'tilt/template'
-
-if RUBY_VERSION >= '1.9.0'
-  require 'csv'
-else
-  require 'fastercsv'
-end
+# frozen_string_literal: true
+require_relative 'template'
+require 'csv'
 
 module Tilt
 
@@ -36,22 +32,14 @@ module Tilt
   class CSVTemplate < Template
     self.default_mime_type = 'text/csv'
 
-    def self.engine
-      if RUBY_VERSION >= '1.9.0' && defined? ::CSV
-        ::CSV
-      elsif defined? ::FasterCSV
-        ::FasterCSV 
-      end
-    end
-
     def prepare
-      @outvar = options.delete(:outvar) || '_csvout'
+      @outvar = @options.delete(:outvar) || '_csvout'
     end
 
     def precompiled_template(locals)
       <<-RUBY
-        #{@outvar} = #{self.class.engine}.generate(**#{options}) do |csv|
-          #{data}
+        #{@outvar} = CSV.generate(**#{@options}) do |csv|
+          #{@data}
         end
       RUBY
     end

data/lib/tilt/erb.rb

@@ -1,30 +1,30 @@
-require 'tilt/template'
+# frozen_string_literal: true
+require_relative 'template'
 require 'erb'
 
 module Tilt
   # ERB template implementation. See:
   # http://www.ruby-doc.org/stdlib/libdoc/erb/rdoc/classes/ERB.html
   class ERBTemplate < Template
-    @@default_output_variable = '_erbout'
-
     SUPPORTS_KVARGS = ::ERB.instance_method(:initialize).parameters.assoc(:key) rescue false
 
-    def self.default_output_variable
-      @@default_output_variable
-    end
-
-    def self.default_output_variable=(name)
-      warn "#{self}.default_output_variable= has been replaced with the :outvar-option"
-      @@default_output_variable = name
-    end
-
     def prepare
-      @outvar = options[:outvar] || self.class.default_output_variable
-      options[:trim] = '<>' if !(options[:trim] == false) && (options[:trim].nil? || options[:trim] == true)
+      @freeze_string_literals = !!@options[:freeze]
+      @outvar = @options[:outvar] || '_erbout'
+      trim = case @options[:trim]
+      when false
+        nil
+      when nil, true
+        '<>'
+      else
+        @options[:trim]
+      end
       @engine = if SUPPORTS_KVARGS
-        ::ERB.new(data, trim_mode: options[:trim], eoutvar: @outvar)
+        ::ERB.new(@data, trim_mode: trim, eoutvar: @outvar)
+      # :nocov:
       else
-        ::ERB.new(data, options[:safe], options[:trim], @outvar)
+        ::ERB.new(@data, options[:safe], trim, @outvar)
+      # :nocov:
       end
     end
 
@@ -52,11 +52,13 @@ module Tilt
 
     # ERB generates a line to specify the character coding of the generated
     # source in 1.9. Account for this in the line offset.
-    if RUBY_VERSION >= '1.9.0'
-      def precompiled(locals)
-        source, offset = super
-        [source, offset + 1]
-      end
+    def precompiled(locals)
+      source, offset = super
+      [source, offset + 1]
+    end
+
+    def freeze_string_literals?
+      @freeze_string_literals
     end
   end
 end

data/lib/tilt/erubi.rb

@@ -1,4 +1,5 @@
-require 'tilt/template'
+# frozen_string_literal: true
+require_relative 'template'
 require 'erubi'
 
 module Tilt
@@ -12,15 +13,33 @@ module Tilt
   #                  instead of the default (which is ::Erubi::Engine).
   class ErubiTemplate < Template
     def prepare
-      @options.merge!(:preamble => false, :postamble => false, :ensure=>true)
+      @options[:preamble] = false
+      @options[:postamble] = false
+      @options[:ensure] = true
 
       engine_class = @options[:engine_class] || Erubi::Engine
 
-      @engine = engine_class.new(data, @options)
-      @outvar = @engine.bufvar
+      # If :freeze option is given, the intent is to setup frozen string
+      # literals in the template.  So enable frozen string literals in the
+      # code Tilt generates if the :freeze option is given.
+      if @freeze_string_literals = !!@options[:freeze]
+        # Passing the :freeze option to Erubi sets the
+        # frozen-string-literal magic comment, which doesn't have an effect
+        # with Tilt as Tilt wraps the resulting code.  Worse, the magic
+        # comment appearing not at the top of the file can cause a warning.
+        # So remove the :freeze option before passing to Erubi.
+        @options.delete(:freeze)
+
+        # Erubi by default appends .freeze to template literals on Ruby 2.1+,
+        # but that is not necessary and slows down code when Tilt is using
+        # frozen string literals, so pass the :freeze_template_literals
+        # option to not append .freeze.
+        @options[:freeze_template_literals] = false
+      end
 
-      # Remove dup after tilt supports frozen source.
-      @src = @engine.src.dup
+      @engine = engine_class.new(@data, @options)
+      @outvar = @engine.bufvar
+      @src = @engine.src
 
       @engine
     end
@@ -28,5 +47,9 @@ module Tilt
     def precompiled_template(locals)
       @src
     end
+
+    def freeze_string_literals?
+      @freeze_string_literals
+    end
   end
 end

data/lib/tilt/erubis.rb

@@ -1,4 +1,5 @@
-require 'tilt/erb'
+# frozen_string_literal: true
+require_relative 'erb'
 require 'erubis'
 
 module Tilt
@@ -16,11 +17,14 @@ module Tilt
   #                   within <%= %> blocks will be automatically html escaped.
   class ErubisTemplate < ERBTemplate
     def prepare
-      @outvar = options.delete(:outvar) || self.class.default_output_variable
-      @options.merge!(:preamble => false, :postamble => false, :bufvar => @outvar)
-      engine_class = options.delete(:engine_class)
-      engine_class = ::Erubis::EscapedEruby if options.delete(:escape_html)
-      @engine = (engine_class || ::Erubis::Eruby).new(data, options)
+      @freeze_string_literals = !!@options.delete(:freeze)
+      @outvar = @options.delete(:outvar) || '_erbout'
+      @options[:preamble] = false
+      @options[:postamble] = false
+      @options[:bufvar] = @outvar
+      engine_class = @options.delete(:engine_class)
+      engine_class = ::Erubis::EscapedEruby if @options.delete(:escape_html)
+      @engine = (engine_class || ::Erubis::Eruby).new(@data, @options)
     end
 
     def precompiled_preamble(locals)
@@ -33,11 +37,13 @@ module Tilt
 
     # Erubis doesn't have ERB's line-off-by-one under 1.9 problem.
     # Override and adjust back.
-    if RUBY_VERSION >= '1.9.0'
-      def precompiled(locals)
-        source, offset = super
-        [source, offset - 1]
-      end
+    def precompiled(locals)
+      source, offset = super
+      [source, offset - 1]
+    end
+
+    def freeze_string_literals?
+      @freeze_string_literals
     end
   end
 end

data/lib/tilt/etanni.rb

@@ -1,4 +1,5 @@
-require 'tilt/template'
+# frozen_string_literal: true
+require_relative 'template'
 
 module Tilt
   class EtanniTemplate < Template
@@ -9,7 +10,7 @@ module Tilt
       stop = "\n#{separator}\n"
       replacement = "#{stop}\\1#{start}"
 
-      temp = data.strip
+      temp = @data.strip
       temp.gsub!(/<\?r\s+(.*?)\s+\?>/m, replacement)
 
       @code = "_out_ = [<<#{separator}.chomp!]\n#{temp}#{stop}_out_.join"

data/lib/tilt/haml.rb

@@ -1,84 +1,92 @@
-require 'tilt/template'
+# frozen_string_literal: true
+require_relative 'template'
 require 'haml'
 
 module Tilt
   # Haml template implementation. See:
   # http://haml.hamptoncatlin.com/
-  class HamlTemplate < Template
-    self.default_mime_type = 'text/html'
+  if defined?(Haml::Template) && Haml::Template < Tilt::Template
+    # Haml >= 6 ships its own template, prefer it when available.
+    HamlTemplate = Haml::Template
+  else
+    class HamlTemplate < Template
+      self.default_mime_type = 'text/html'
 
-    # `Gem::Version.correct?` may return false because of Haml::VERSION #=> "3.1.8 (Separated Sally)". After Haml 4, it's always correct.
-    if Gem::Version.correct?(Haml::VERSION) && Gem::Version.new(Haml::VERSION) >= Gem::Version.new('5.0.0.beta.2')
-      def prepare
-        options = {}.update(@options).update(filename: eval_file, line: line)
-        if options.include?(:outvar)
-          options[:buffer] = options.delete(:outvar)
-          options[:save_buffer] = true
+      # `Gem::Version.correct?` may return false because of Haml::VERSION #=> "3.1.8 (Separated Sally)". After Haml 4, it's always correct.
+      if Gem::Version.correct?(Haml::VERSION) && Gem::Version.new(Haml::VERSION) >= Gem::Version.new('5.0.0.beta.2')
+        def prepare
+          @options[:filename] = eval_file
+          @options[:line] = @line
+          if @options.include?(:outvar)
+            @options[:buffer] = @options.delete(:outvar)
+            @options[:save_buffer] = true
+          end
+          @engine = ::Haml::TempleEngine.new(@options)
+          @engine.compile(@data)
         end
-        @engine = ::Haml::TempleEngine.new(options)
-        @engine.compile(data)
-      end
 
-      def evaluate(scope, locals, &block)
-        raise ArgumentError, 'invalid scope: must not be frozen' if scope.frozen?
-        super
-      end
+        def evaluate(scope, locals, &block)
+          raise ArgumentError, 'invalid scope: must not be frozen' if scope.frozen?
+          super
+        end
 
-      def precompiled_template(locals)
-        @engine.precompiled_with_ambles(
-          [],
-          after_preamble: <<-RUBY
-            __in_erb_template = true
-            _haml_locals = locals
-          RUBY
-        )
-      end
-    else # Following definitions are for Haml <= 4 and deprecated.
-      def prepare
-        options = @options.merge(:filename => eval_file, :line => line)
-        @engine = ::Haml::Engine.new(data, options)
-      end
+        def precompiled_template(locals)
+          @engine.precompiled_with_ambles(
+            [],
+            after_preamble: <<-RUBY
+              __in_erb_template = true
+              _haml_locals = locals
+            RUBY
+          )
+        end
+      else # Following definitions are for Haml <= 4 and deprecated.
+        def prepare
+          @options[:filename] = eval_file
+          @options[:line] = @line
+          @engine = ::Haml::Engine.new(@data, @options)
+        end
 
-      def evaluate(scope, locals, &block)
-        raise ArgumentError, 'invalid scope: must not be frozen' if scope.frozen?
+        def evaluate(scope, locals, &block)
+          raise ArgumentError, 'invalid scope: must not be frozen' if scope.frozen?
 
-        if @engine.respond_to?(:precompiled_method_return_value, true)
-          super
-        else
-          @engine.render(scope, locals, &block)
+          if @engine.respond_to?(:precompiled_method_return_value, true)
+            super
+          else
+            @engine.render(scope, locals, &block)
+          end
         end
-      end
 
-      # Precompiled Haml source. Taken from the precompiled_with_ambles
-      # method in Haml::Precompiler:
-      # http://github.com/nex3/haml/blob/master/lib/haml/precompiler.rb#L111-126
-      def precompiled_template(locals)
-        @engine.precompiled
-      end
+        # Precompiled Haml source. Taken from the precompiled_with_ambles
+        # method in Haml::Precompiler:
+        # http://github.com/nex3/haml/blob/master/lib/haml/precompiler.rb#L111-126
+        def precompiled_template(locals)
+          @engine.precompiled
+        end
 
-      def precompiled_preamble(locals)
-        local_assigns = super
-        @engine.instance_eval do
-          <<-RUBY
-            begin
-              extend Haml::Helpers
-              _hamlout = @haml_buffer = Haml::Buffer.new(haml_buffer, #{options_for_buffer.inspect})
-              _erbout = _hamlout.buffer
-              __in_erb_template = true
-              _haml_locals = locals
-              #{local_assigns}
-          RUBY
+        def precompiled_preamble(locals)
+          local_assigns = super
+          @engine.instance_eval do
+            <<-RUBY
+              begin
+                extend Haml::Helpers
+                _hamlout = @haml_buffer = Haml::Buffer.new(haml_buffer, #{options_for_buffer.inspect})
+                _erbout = _hamlout.buffer
+                __in_erb_template = true
+                _haml_locals = locals
+                #{local_assigns}
+            RUBY
+          end
         end
-      end
 
-      def precompiled_postamble(locals)
-        @engine.instance_eval do
-          <<-RUBY
-              #{precompiled_method_return_value}
-            ensure
-              @haml_buffer = @haml_buffer.upper if haml_buffer
-            end
-          RUBY
+        def precompiled_postamble(locals)
+          @engine.instance_eval do
+            <<-RUBY
+                #{precompiled_method_return_value}
+              ensure
+                @haml_buffer = @haml_buffer.upper if haml_buffer
+              end
+            RUBY
+          end
         end
       end
     end

data/lib/tilt/kramdown.rb

@@ -1,25 +1,13 @@
-require 'tilt/template'
+# frozen_string_literal: true
+require_relative 'template'
 require 'kramdown'
 
-module Tilt
-  # Kramdown Markdown implementation. See:
-  # http://kramdown.rubyforge.org/
-  class KramdownTemplate < Template
-    DUMB_QUOTES = [39, 39, 34, 34]
+dumb_quotes = [39, 39, 34, 34].freeze
 
-    def prepare
-      options[:smart_quotes] = DUMB_QUOTES unless options[:smartypants]
-      @engine = Kramdown::Document.new(data, options)
-      @output = nil
-    end
+# Kramdown Markdown implementation. See: https://kramdown.gettalong.org/
+Tilt::KramdownTemplate = Tilt::StaticTemplate.subclass do
+  # dup as Krawmdown modifies the passed option with map!
+  @options[:smart_quotes] = dumb_quotes.dup unless @options[:smartypants]
 
-    def evaluate(scope, locals, &block)
-      @output ||= @engine.to_html
-    end
-
-    def allows_script?
-      false
-    end
-  end
+  Kramdown::Document.new(@data, @options).to_html
 end
-

data/lib/tilt/liquid.rb

@@ -1,11 +1,12 @@
-require 'tilt/template'
+# frozen_string_literal: true
+require_relative 'template'
 require 'liquid'
 
 module Tilt
   # Liquid template implementation. See:
   # http://liquidmarkup.org/
   #
-  # Liquid is designed to be a *safe* template system and threfore
+  # Liquid is designed to be a *safe* template system and therefore
   # does not provide direct access to execuatable scopes. In order to
   # support a +scope+, the +scope+ must be able to represent itself
   # as a hash by responding to #to_h. If the +scope+ does not respond
@@ -17,16 +18,17 @@ module Tilt
   # time when using this template engine.
   class LiquidTemplate < Template
     def prepare
-      @engine = ::Liquid::Template.parse(data, liquid_options)
+      @options[:line_numbers] = true unless @options.has_key?(:line_numbers)
+      @engine = ::Liquid::Template.parse(@data, @options)
     end
 
-    def evaluate(scope, locals, &block)
-      locals = locals.inject({}){ |h,(k,v)| h[k.to_s] = v ; h }
+    def evaluate(scope, locs)
+      locals = {}
       if scope.respond_to?(:to_h)
-        scope  = scope.to_h.inject({}){ |h,(k,v)| h[k.to_s] = v ; h }
-        locals = scope.merge(locals)
+        scope.to_h.each{|k, v| locals[k.to_s] = v}
       end
-      locals['yield'] = block.nil? ? '' : yield
+      locs.each{|k, v| locals[k.to_s] = v}
+      locals['yield'] = block_given? ? yield : ''
       locals['content'] = locals['yield']
       @engine.render(locals)
     end
@@ -34,11 +36,5 @@ module Tilt
     def allows_script?
       false
     end
-
-    private
-
-    def liquid_options
-      { line_numbers: true }.merge options
-    end
   end
 end

data/lib/tilt/livescript.rb

@@ -1,23 +1,11 @@
-require 'tilt/template'
+# frozen_string_literal: true
+require_relative 'template'
 require 'livescript'
 
-module Tilt
-  # LiveScript template implementation. See:
-  # http://livescript.net/
-  #
-  # LiveScript templates do not support object scopes, locals, or yield.
-  class LiveScriptTemplate < Template
-    self.default_mime_type = 'application/javascript'
-
-    def prepare
-    end
-
-    def evaluate(scope, locals, &block)
-      @output ||= LiveScript.compile(data, options)
-    end
-
-    def allows_script?
-      false
-    end
-  end
+# LiveScript template implementation. See:
+# http://livescript.net/
+#
+# LiveScript templates do not support object scopes, locals, or yield.
+Tilt::LiveScriptTemplate = Tilt::StaticTemplate.subclass(mime_type: 'application/javascript') do
+  LiveScript.compile(@data, @options)
 end