tilt 2.0.10 → 2.2.0

data/lib/tilt/prawn.rb

@@ -1,43 +1,35 @@
-require 'tilt/template'
+# frozen_string_literal: true
+require_relative 'template'
 require 'prawn'
 
 module Tilt
   # Prawn template implementation. See: http://prawnpdf.org
-  #
   class PrawnTemplate < Template
     self.default_mime_type = 'application/pdf'
     
     def prepare
-      @engine = ::Prawn::Document.new(prawn_options)
+      @options[:page_size] = 'A4' unless @options.has_key?(:page_size)
+      @options[:page_layout] = :portrait unless @options.has_key?(:page_layout)
+      @engine = ::Prawn::Document.new(@options)
     end
     
     def evaluate(scope, locals, &block)
       pdf = @engine
-      if data.respond_to?(:to_str)
+      if @data.respond_to?(:to_str)
+        locals = locals.dup
         locals[:pdf] = pdf
-        super(scope, locals, &block)
-      elsif data.kind_of?(Proc)
-        data.call(pdf)
+        super
+      else
+        warn "Non-string provided as prawn template data. This is no longer supported and support for it will be removed in Tilt 2.3", :uplevel=>2
+        # :nocov:
+        @data.call(pdf) if @data.kind_of?(Proc)
+        # :nocov:
       end
-      @output ||= pdf.render
-    end
-    
-    def allows_script?
-      false
+      pdf.render
     end
     
     def precompiled_template(locals)
-      data.to_str
+      @data.to_str
     end
-    
-    
-    private
-      
-      def prawn_options
-        # defaults to A4 instead of crazy US Letter format. 
-        { :page_size => "A4", :page_layout => :portrait }.merge(options)
-      end
-      
   end
-  
 end

data/lib/tilt/radius.rb

@@ -1,44 +1,37 @@
-require 'tilt/template'
+# frozen_string_literal: true
+require_relative 'template'
 require 'radius'
 
 module Tilt
   # Radius Template
   # http://github.com/jlong/radius/
   class RadiusTemplate < Template
-    def self.context_class
-      @context_class ||= Class.new(Radius::Context) do
-        attr_accessor :tilt_scope
+    class ContextClass < Radius::Context
+      attr_accessor :tilt_scope
 
-        def tag_missing(name, attributes)
-          tilt_scope.__send__(name)
-        end
-
-        def dup
-          i = super
-          i.tilt_scope = tilt_scope
-          i
-        end
+      def tag_missing(name, attributes)
+        tilt_scope.__send__(name)
       end
-    end
 
-    def prepare
+      def dup
+        i = super
+        i.tilt_scope = tilt_scope
+        i
+      end
     end
 
     def evaluate(scope, locals, &block)
-      context = self.class.context_class.new
+      context = ContextClass.new
       context.tilt_scope = scope
-      context.define_tag("yield") do
-        block.call
-      end
+      context.define_tag("yield", &block) if block
       locals.each do |tag, value|
         context.define_tag(tag) do
           value
         end
       end
 
-      options = {:tag_prefix => 'r'}.merge(@options)
-      parser = Radius::Parser.new(context, options)
-      parser.parse(data)
+      @options[:tag_prefix] = 'r' unless @options.has_key?(:tag_prefix)
+      Radius::Parser.new(context, @options).parse(@data)
     end
 
     def allows_script?

data/lib/tilt/rdiscount.rb

@@ -1,39 +1,23 @@
-require 'tilt/template'
+# frozen_string_literal: true
+require_relative 'template'
 require 'rdiscount'
 
-module Tilt
-  # Discount Markdown implementation. See:
-  # http://github.com/rtomayko/rdiscount
-  #
-  # RDiscount is a simple text filter. It does not support +scope+ or
-  # +locals+. The +:smart+ and +:filter_html+ options may be set true
-  # to enable those flags on the underlying RDiscount object.
-  class RDiscountTemplate < Template
-    self.default_mime_type = 'text/html'
+aliases = {
+  :escape_html => :filter_html,
+  :smartypants => :smart
+}.freeze
 
-    ALIAS = {
-      :escape_html => :filter_html,
-      :smartypants => :smart
-    }
+_flags = [:smart, :filter_html, :smartypants, :escape_html].freeze
 
-    FLAGS = [:smart, :filter_html, :smartypants, :escape_html]
+# Discount Markdown implementation. See:
+# http://github.com/rtomayko/rdiscount
+#
+# RDiscount is a simple text filter. It does not support +scope+ or
+# +locals+. The +:smart+ and +:filter_html+ options may be set true
+# to enable those flags on the underlying RDiscount object.
+Tilt::RDiscountTemplate = Tilt::StaticTemplate.subclass do
+  flags = _flags.select { |flag| @options[flag] }.
+    map! { |flag| aliases[flag] || flag }
 
-    def flags
-      FLAGS.select { |flag| options[flag] }.map { |flag| ALIAS[flag] || flag }
-    end
-
-    def prepare
-      @engine = RDiscount.new(data, *flags)
-      @output = nil
-    end
-
-    def evaluate(scope, locals, &block)
-      @output ||= @engine.to_html
-    end
-
-    def allows_script?
-      false
-    end
-  end
+  RDiscount.new(@data, *flags).to_html
 end
-

data/lib/tilt/rdoc.rb

@@ -1,40 +1,19 @@
-require 'tilt/template'
+# frozen_string_literal: true
+require_relative 'template'
 require 'rdoc'
 require 'rdoc/markup'
 require 'rdoc/markup/to_html'
+require 'rdoc/options'
 
-module Tilt
-  # RDoc template. See:
-  # http://rdoc.rubyforge.org/
-  #
-  # It's suggested that your program `require 'rdoc/markup'` and
-  # `require 'rdoc/markup/to_html'` at load time when using this template
-  # engine in a threaded environment.
-  class RDocTemplate < Template
-    self.default_mime_type = 'text/html'
-
-    def markup
-      begin
-        # RDoc 4.0
-        require 'rdoc/options'
-        RDoc::Markup::ToHtml.new(RDoc::Options.new, nil)
-      rescue ArgumentError
-        # RDoc < 4.0
-        RDoc::Markup::ToHtml.new
-      end
-    end
-
-    def prepare
-      @engine = markup.convert(data)
-      @output = nil
-    end
-
-    def evaluate(scope, locals, &block)
-      @output ||= @engine.to_s
-    end
-
-    def allows_script?
-      false
-    end
-  end
+# RDoc template. See: https://github.com/ruby/rdoc
+#
+# It's suggested that your program run the following at load time when
+# using this templae engine in a threaded environment:
+#
+#   require 'rdoc'
+#   require 'rdoc/markup'
+#   require 'rdoc/markup/to_html'
+#   require 'rdoc/options'
+Tilt::RDocTemplate = Tilt::StaticTemplate.subclass do
+  RDoc::Markup::ToHtml.new(RDoc::Options.new, nil).convert(@data).to_s
 end

data/lib/tilt/redcarpet.rb

@@ -1,46 +1,34 @@
-require 'tilt/template'
+# frozen_string_literal: true
+require_relative 'template'
 require 'redcarpet'
 
-module Tilt
-  # Compatibility mode for Redcarpet 1.x
-  class Redcarpet1Template < Template
-    self.default_mime_type = 'text/html'
+aliases = {:escape_html => :filter_html, :smartypants => :smart}.freeze
 
-    ALIAS = {
-      :escape_html => :filter_html,
-      :smartypants => :smart
-    }
+# :nocov:
+unless defined? ::Redcarpet::Render and defined? ::Redcarpet::Markdown
+  # Redcarpet 1.x
+  warn "Tilt support for RedCarpet 1.x is deprecated and will be removed in Tilt 2.3", uplevel: 1
+  _flags = [:smart, :filter_html, :smartypants, :escape_html]
 
-    FLAGS = [:smart, :filter_html, :smartypants, :escape_html]
-
-    def flags
-      FLAGS.select { |flag| options[flag] }.map { |flag| ALIAS[flag] || flag }
-    end
-
-    def prepare
-      @engine = RedcarpetCompat.new(data, *flags)
-      @output = nil
-    end
-
-    def evaluate(scope, locals, &block)
-      @output ||= @engine.to_html
-    end
-
-    def allows_script?
-      false
-    end
+  Tilt::RedcarpetTemplate = Tilt::StaticTemplate.subclass do
+    flags = _flags.select { |flag| @options[flag] }.map! { |flag| aliases[flag] || flag }
+    RedcarpetCompat.new(@data, *flags).to_html
   end
+# :nocov:
+else
+  Tilt::RedcarpetTemplate = Tilt::StaticTemplate.subclass do
+    aliases.each do |opt, aka|
+      if options.key?(aka) || !@options.key?(opt)
+        @options[opt] = @options.delete(aka)
+      end
+    end
 
-  # Future proof mode for Redcarpet 2.x (not yet released)
-  class Redcarpet2Template < Template
-    self.default_mime_type = 'text/html'
-
-    def generate_renderer
-      renderer = options.delete(:renderer) || ::Redcarpet::Render::HTML.new(options)
-      return renderer unless options.delete(:smartypants)
-      return renderer if renderer.is_a?(Class) && renderer <= ::Redcarpet::Render::SmartyPants
+    # only raise an exception if someone is trying to enable :escape_html
+    @options.delete(:escape_html) unless @options[:escape_html]
 
-      if renderer == ::Redcarpet::Render::XHTML
+    renderer = @options.delete(:renderer) || ::Redcarpet::Render::HTML.new(@options)
+    if options.delete(:smartypants) && !(renderer.is_a?(Class) && renderer <= ::Redcarpet::Render::SmartyPants)
+      renderer = if renderer == ::Redcarpet::Render::XHTML
         ::Redcarpet::Render::SmartyHTML.new(:xhtml => true)
       elsif renderer == ::Redcarpet::Render::HTML
         ::Redcarpet::Render::SmartyHTML
@@ -51,33 +39,6 @@ module Tilt
       end
     end
 
-    def prepare
-      # try to support the same aliases
-      Redcarpet1Template::ALIAS.each do |opt, aka|
-        next if options.key? opt or not options.key? aka
-        options[opt] = options.delete(aka)
-      end
-
-      # only raise an exception if someone is trying to enable :escape_html
-      options.delete(:escape_html) unless options[:escape_html]
-
-      @engine = ::Redcarpet::Markdown.new(generate_renderer, options)
-      @output = nil
-    end
-
-    def evaluate(scope, locals, &block)
-      @output ||= @engine.render(data)
-    end
-
-    def allows_script?
-      false
-    end
-  end
-
-  if defined? ::Redcarpet::Render and defined? ::Redcarpet::Markdown
-    RedcarpetTemplate = Redcarpet2Template
-  else
-    RedcarpetTemplate = Redcarpet1Template
+    Redcarpet::Markdown.new(renderer, @options).render(@data)
   end
 end
-

data/lib/tilt/redcloth.rb

@@ -1,23 +1,13 @@
-require 'tilt/template'
+# frozen_string_literal: true
+require_relative 'template'
 require 'redcloth'
 
-module Tilt
-  # RedCloth implementation. See:
-  # http://redcloth.org/
-  class RedClothTemplate < Template
-    def prepare
-      @engine = RedCloth.new(data)
-      options.each {|k, v| @engine.send("#{k}=", v) if @engine.respond_to? "#{k}="}
-      @output = nil
-    end
-
-    def evaluate(scope, locals, &block)
-      @output ||= @engine.to_html
-    end
-
-    def allows_script?
-      false
-    end
+# RedCloth implementation. See: https://github.com/jgarber/redcloth
+Tilt::RedClothTemplate = Tilt::StaticTemplate.subclass do
+  engine = RedCloth.new(@data)
+  @options.each  do |k, v|
+    m = :"#{k}="
+    engine.send(m, v) if engine.respond_to? m
   end
+  engine.to_html
 end
-

data/lib/tilt/rst-pandoc.rb

@@ -1,18 +1,10 @@
-require 'tilt/template'
-require 'tilt/pandoc'
+# frozen_string_literal: true
+require_relative 'template'
+require_relative 'pandoc'
 
-module Tilt
-  # Pandoc reStructuredText implementation. See:
-  # http://pandoc.org/
-  # Use PandocTemplate and specify input format
-  class RstPandocTemplate < PandocTemplate
-    def tilt_to_pandoc_mapping
-      { :smartypants => :smart }
-    end
+rst = {:f => "rst"}.freeze
 
-    def pandoc_options
-      options.merge!(f: 'rst')
-      super
-    end
-  end
+# Pandoc reStructuredText implementation. See: # http://pandoc.org/
+Tilt::RstPandocTemplate = Tilt::StaticTemplate.subclass do
+  PandocRuby.new(@data, rst).to_html.strip
 end

data/lib/tilt/sass.rb

@@ -1,52 +1,69 @@
-require 'tilt/template'
+# frozen_string_literal: true
+require_relative 'template'
 
 module Tilt
-  # Sass template implementation. See:
-  # http://haml.hamptoncatlin.com/
+  # Sass template implementation for generating CSS. See: https://sass-lang.com/
   #
   # Sass templates do not support object scopes, locals, or yield.
-  class SassTemplate < Template
+  class SassTemplate < StaticTemplate
     self.default_mime_type = 'text/css'
 
     begin
-      require 'sassc'
-      Sass = ::SassC
+      require 'sass-embedded'
+    # :nocov:
+      require 'uri'
+
+      private
+
+      def _prepare_output
+        ::Sass.compile_string(@data, **sass_options).css
+      end
+
+      def sass_options
+        path = File.absolute_path(eval_file)
+        path = '/' + path unless path.start_with?('/')
+        @options[:url] = ::URI::File.build([nil, ::URI::DEFAULT_PARSER.escape(path)]).to_s
+        @options[:syntax] = :indented
+        @options
+      end
     rescue LoadError => err
       begin
-        require 'sass'
-        Sass = ::Sass
+        require 'sassc'
+        Engine = ::SassC::Engine
       rescue LoadError
-        raise err
+        begin
+          require 'sass'
+          Engine = ::Sass::Engine
+        rescue LoadError
+          raise err
+        end
       end
-    end
-
-    def prepare
-      @engine = Sass::Engine.new(data, sass_options)
-    end
 
-    def evaluate(scope, locals, &block)
-      @output ||= @engine.render
-    end
+      private
 
-    def allows_script?
-      false
-    end
+      def _prepare_output
+        Engine.new(@data, sass_options).render
+      end
 
-  private
-    def sass_options
-      options.merge(:filename => eval_file, :line => line, :syntax => :sass)
+      def sass_options
+        @options[:filename] = eval_file
+        @options[:line] = @line
+        @options[:syntax] = :sass
+        @options
+      end
+    # :nocov:
     end
   end
 
-  # Sass's new .scss type template implementation.
   class ScssTemplate < SassTemplate
     self.default_mime_type = 'text/css'
 
-  private
+    private
+
     def sass_options
-      options.merge(:filename => eval_file, :line => line, :syntax => :scss)
+      super
+      @options[:syntax] = :scss
+      @options
     end
   end
-
 end
-

data/lib/tilt/slim.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+require_relative 'template'
+require 'slim'
+
+Tilt::SlimTemplate = Slim::Template

data/lib/tilt/string.rb

@@ -1,12 +1,13 @@
-require 'tilt/template'
+# frozen_string_literal: true
+require_relative 'template'
 
 module Tilt
   # The template source is evaluated as a Ruby string. The #{} interpolation
   # syntax can be used to generated dynamic output.
   class StringTemplate < Template
     def prepare
-      hash = "TILT#{data.hash.abs}"
-      @code = String.new("<<#{hash}.chomp\n#{data}\n#{hash}")
+      hash = "TILT#{@data.hash.abs}"
+      @code = String.new("<<#{hash}.chomp\n#{@data}\n#{hash}")
     end
 
     def precompiled_template(locals)