RubyGems - tilt - Versions diffs - 2.0.11 → 2.7.0 - Mend

tilt 2.0.11 → 2.7.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (50) hide show

data/lib/tilt/haml.rb CHANGED Viewed

@@ -1,84 +1,158 @@
-require 'tilt/template'
+# frozen_string_literal: true
+# = Haml (<tt>haml</tt>)
+#
+# {Haml}[https://haml.info] is a markup language that’s used to cleanly and simply describe
+# the HTML of any web document without the use of inline code. Haml functions as
+# a replacement for inline page templating systems such as PHP, ASP, and ERB, the
+# templating language used in most Ruby on Rails applications. However, Haml
+# avoids the need for explicitly coding HTML into the template, because it itself
+# is a description of the HTML, with some code to generate dynamic content.
+# ({more}[http://haml.info/about.html)]
+#
+# === Example
+#
+#     %html
+#       %head
+#         %title= @title
+#       %body
+#         %h1
+#           Hello
+#           = world + '!'
+#
+# === Usage
+#
+# The <tt>Tilt::HamlTemplate</tt> class is registered for all files ending in <tt>.haml</tt>
+# by default. Haml templates support custom evaluation scopes and locals:
+#
+#     >> require 'haml'
+#     >> template = Tilt.new('hello.haml')
+#     => #<Tilt::HamlTemplate @file='hello.haml'>
+#     >> @title = "Hello Haml!"
+#     >> template.render(self, :world => 'Haml!')
+#     => "
+#     <html>
+#       <head>
+#         <title>Hello Haml!</title>
+#       </head>
+#       <body>
+#         <h1>Hello Haml!</h1>
+#       </body>
+#     </html>"
+#
+# Or, use the <tt>Tilt::HamlTemplate</tt> class directly to process strings:
+#
+#     >> require 'haml'
+#     >> template = Tilt::HamlTemplate.new { "%h1= 'Hello Haml!'" }
+#     => #<Tilt::HamlTemplate @file=nil ...>
+#     >> template.render
+#     => "<h1>Hello Haml!</h1>"
+#
+# __NOTE:__ It's suggested that your program <tt>require 'haml'</tt> at load time when
+# using this template engine within a threaded environment.
+#
+# === Options
+#
+# Please see the {Haml Reference}[http://haml.info/docs/yardoc/file.HAML_REFERENCE.html#options] for all available options.
+#
+# === See also
+#
+# * {#haml.docs}[http://haml.info/docs.html]
+# * {Haml Tutorial}[http://haml.info/tutorial.html]
+# * {Haml Reference}[http://haml.info/docs/yardoc/file.HAML_REFERENCE.html]
+#
+# === Related module
+#
+# * Tilt::HamlTemplate
+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
+      # <tt>Gem::Version.correct?</tt> 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 CHANGED Viewed

@@ -1,25 +1,59 @@
-require 'tilt/template'
-require 'kramdown'
+# frozen_string_literal: true
+# = Markdown (<tt>markdown</tt>, <tt>md</tt>, <tt>mkd</tt>)
+#
+# Markdown is a lightweight markup language, created by John Gruber
+# and Aaron Swartz. For any markup that is not covered by Markdown’s syntax, HTML
+# is used.  Marking up plain text with Markdown markup is easy and Markdown
+# formatted texts are readable.
+#
+# === Example
+#
+#     Hello Markdown Templates
+#     ========================
+#
+#     Hello World. This is a paragraph.
+#
+# === Usage
+#
+# To wrap a Markdown formatted document with a layout:
+#
+#     layout = Tilt['erb'].new do
+#       "<!doctype html><title></title><%= yield %>"
+#     end
+#     data = Tilt['md'].new { "# hello tilt" }
+#     layout.render { data.render }
+#     # => "<!doctype html><title></title><h1>hello tilt</h1>\n"
+#
+# === Options
+#
+# Every implementation of Markdown *should* support these options, but there are
+# some known problems with the Kramdown engine.
+#
+# ==== <tt>:smartypants => true|false</tt>
+#
+# Set <tt>true</tt> to enable [Smarty Pants][smartypants] style punctuation replacement.
+#
+# In Kramdown this option only applies to smart quotes. It will apply a
+# subset of Smarty Pants (e.g. <tt>...</tt> to <tt>…</tt>) regardless of any option.
+#
+# ==== <tt>:escape_html => true|false</tt>
+#
+# Kramdown doesn't support this option.
+#
+# === See also
+#
+# * {Markdown Syntax Documentation}[http://daringfireball.net/projects/markdown/syntax]
+# * {Kramdown Markdown implementation}[https://kramdown.gettalong.org]
-module Tilt
-  # Kramdown Markdown implementation. See:
-  # http://kramdown.rubyforge.org/
-  class KramdownTemplate < Template
-    DUMB_QUOTES = [39, 39, 34, 34]
+require_relative 'template'
+require 'kramdown'
-    def prepare
-      options[:smart_quotes] = DUMB_QUOTES unless options[:smartypants]
-      @engine = Kramdown::Document.new(data, options)
-      @output = nil
-    end
+dumb_quotes = [39, 39, 34, 34].freeze
-    def evaluate(scope, locals, &block)
-      @output ||= @engine.to_html
-    end
+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 allows_script?
-      false
-    end
-  end
+  Kramdown::Document.new(@data, @options).to_html
 end

data/lib/tilt/liquid.rb CHANGED Viewed

@@ -1,32 +1,87 @@
-require 'tilt/template'
+# frozen_string_literal: true
+# = Liquid (<tt>liquid</tt>)
+#
+# 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
+# to #to_h it will be ignored.
+#
+# LiquidTemplate does not support yield blocks.
+#
+# === Example
+#
+#     <html>
+#       <head>
+#         <title>{{ title }}</title>
+#       </head>
+#       <body>
+#         <h1>Hello {{ world }}!</h1>
+#       </body>
+#     </html>
+#
+# === Usage
+#
+# <tt>Tilt::LiquidTemplate</tt> is registered for all files ending in <tt>.liquid</tt> by
+# default. Liquid templates support locals and objects that respond to
+# <tt>#to_h</tt> as scopes:
+#
+#     >> require 'liquid'
+#     >> require 'tilt'
+#     >> template = Tilt.new('hello.liquid')
+#     => #<Tilt::LiquidTemplate @file='hello.liquid'>
+#     >> scope = { :title => "Hello Liquid Templates" }
+#     >> template.render(nil, :world => "Liquid")
+#     => "
+#     <html>
+#       <head>
+#         <title>Hello Liquid Templates</title>
+#       </head>
+#       <body>
+#         <h1>Hello Liquid!</h1>
+#       </body>
+#     </html>"
+#
+# Or, use <tt>Tilt::LiquidTemplate</tt> directly to process strings:
+#
+#     >> require 'liquid'
+#     >> template = Tilt::LiquidTemplate.new { "<h1>Hello Liquid!</h1>" }
+#     => #<Tilt::LiquidTemplate @file=nil ...>
+#     >> template.render
+#     => "<h1>Hello Liquid!</h1>"
+#
+# __NOTE:__ It's suggested that your program <tt>require 'liquid'</tt> at load
+# time when using this template engine within a threaded environment.
+#
+# === See also
+#
+# * {Liquid}[http://liquidmarkup.org]
+# * {Liquid for Programmers}[https://wiki.github.com/Shopify/liquid/liquid-for-programmers]
+# * {Liquid Docs}[http://liquid.rubyforge.org/]
+# * GitHub: {Shopify/liquid}[https://github.com/Shopify/liquid/]
+#
+# === Related module
+#
+# * Tilt::LiquidTemplate
+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
-  # 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
-  # to #to_h it will be ignored.
-  #
-  # LiquidTemplate does not support yield blocks.
-  #
-  # It's suggested that your program require 'liquid' at load
-  # 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 +89,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 CHANGED Viewed

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