temple 0.6.7 → 0.10.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 39b989dfbda6a7b4cd349b3580cb3352a1fbe16c
-  data.tar.gz: f83ebdd80cbfe3a87cb40ee1e82b04e7985ccc95
+SHA256:
+  metadata.gz: c7475d628203a95d9ec067ac1388f8428cb213f4534a2fd2ed1b9cf0be7d3293
+  data.tar.gz: d828006ab486aee65e70e8e321022d28191deba994d43c1141dccad2815f41f2
 SHA512:
-  metadata.gz: 4cd1b41809a7d563c7c3d91c8311dde78c093ca04e279210666b4160c4b33b9efb0d21b8ca7532087536b3d4078ef912957255474189d0129a278c3d149ad42e
-  data.tar.gz: 1daf0219baec00f3e4a768b5a4560992ceb65c2aa8a255b9cf7e266d9e1a23432ac41ffa8cc6b953950dc659d6205f312e0d033a6fcdd6c5689153b1fc84d5c1
+  metadata.gz: d74cc956889989a4d65f6727d7f521cbcbf3d9c2de1a6abda92b4957a7e3992de2b7de6c7634b4dfafe9d4ce1a505f22b8f5af1ef9a217876d6d67f276e04557
+  data.tar.gz: 1958e441fbab605e06f560db0f4c26e5fecf7c673a12a5aad843a3bd5bb4c0ce77e3c2ea13f46b22d962770898587b7f76bd0ad2b11377898e61924e7bc20c87

data/.github/workflows/test.yml

@@ -0,0 +1,34 @@
+name: test
+on:
+  push:
+    branches:
+      - master
+  pull_request:
+    types:
+      - opened
+      - synchronize
+      - reopened
+  schedule:
+    - cron: "00 15 * * *"
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        ruby:
+          - '2.5'
+          - '2.6'
+          - '2.7'
+          - '3.0'
+          - '3.1'
+          - jruby
+          - truffleruby-head
+    steps:
+      - uses: actions/checkout@v2
+      - name: Set up Ruby
+        uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: ${{ matrix.ruby }}
+          bundler-cache: true
+      - run: bundle exec rake spec

data/.gitignore

@@ -2,3 +2,4 @@ coverage
 .yardoc
 doc
 Gemfile.lock
+/pkg/

data/CHANGES

@@ -1,3 +1,108 @@
+0.10.0
+
+  * Regression: Revert changes to :capture_generator since 0.8.2 (#112, #113, #137)
+  * Regression: Ensure that output buffer is not reused for capturing in Rails (#135)
+  * Drop support for Rails 4.x
+
+0.9.1
+
+  * Fix Slim's error in AttributeMerger due to 0.9.0's :capture_generator (#137)
+  * Use specified :capture_generator for nested captures (#112)
+  * Fix Temple::ERB::Engine's <%= to not escape and <%== to escape expressions
+
+0.9.0
+
+  * Require Ruby 2.5+ (#131)
+  * Change default :capture_generator to self (#113)
+  * Improve compatibility with Rails 7.1 (#135)
+  * Support Rails 6.1's annotate_rendered_view_with_filenames
+    with Temple::Filters::Ambles (#134)
+  * Fix a crash in StringSplitter filter (#138)
+  * Fix a warning by Object#=~ since Ruby 2.6 (#129)
+  * Fix deprecated Tilt template mime type (#108)
+  * Stop using deprecated EscapeUtils from Temple::Utils (#136)
+
+0.8.2
+
+  * Support TruffleRuby in Temple::Filters::StaticAnalyzer (#127)
+  * Support TruffleRuby in Temple::Filters::StringSplitter (#127)
+
+0.8.1
+
+  * Stop relying on deprecated method in Rails (#121)
+  * Fix issue with --enable-frozen-string-literal
+  * Escape html in markdown
+
+0.8.0
+
+  * Add Temple::StaticAnalyzer to analyze Ruby expressions
+  * Support newlines in Temple::Filters::StaticAnalyzer
+
+0.7.8
+
+  * Fix a warning in StaticAnalyzer
+
+0.7.7
+
+  * Add Temple::Filters::StaticAnalyzer, Temple::Filters::StringSplitter
+  * Freeze string literals
+
+0.7.6
+
+  * EngineDSL - add support for use(:Filter) { FilterClassName }
+
+0.7.5
+
+  * HTML::Pretty Fix indentation issue (https://github.com/slim-template/slim-rails/issues/78)
+
+0.7.4
+
+  * EngineDSL: allow to replace/remove with regexp
+  * Fix deprecation warning (#83)
+
+0.7.3
+
+  * Temple::ERB::Trimming - replace option trim_mode with trim and switch to erubis-like trimming
+
+0.7.2
+
+  * Remove Filters::StaticFreezer, the generator does the freezing
+
+0.7.1
+
+  * Rename *Hash to *Map
+  * Add Filters::StaticFreezer
+
+0.7.0
+
+  * Drop Ruby 1.8.7 support
+  * EngineDSL: Remove option filter
+  * HTML: Deprecate :html4, :html5 formats
+  * HTML: Add format :xml
+  * Rename DefaultOptions to ClassOptions
+  * Deprecate default_options in favor of options
+  * Add Utils.indent_dynamic
+
+0.6.10
+
+  * Tilt template: Support :outvar and save/restore buffer to make the behaviour compatible with ERB
+
+0.6.9
+
+  * HTML::Pretty: Fix wrong line numbers
+  * Tilt template: Don't overwrite buffer always
+  * Generator: add preamble and postamble which do nothing
+  * Tilt template: don't overwrite streaming option
+  * OptionHash: inherit valid keys
+  * temple/html/safe: add poor man's html_safe? implementation (not required automatically)
+  * Temple::Mixins::GrammarDSL - Add some missing match? methods
+  * Temple::Utils.escape_html_safe - Add parameter safe
+
+0.6.8
+
+  * HTML::Fast add svg doctype
+  * Render standalone html 5 attributes
+
 0.6.7
 
   * HTML::Pretty - change some block level tags
@@ -172,7 +277,7 @@
 
 0.1.1
 
-  * Test added  
+  * Test added
 
 0.1.0
 

data/EXPRESSIONS.md

@@ -188,7 +188,7 @@ The HTML abstraction is processed by the html filters (Temple::HTML::Fast and Te
 Example:
     [:html, :doctype, '5']
 generates
-    <!DOCTYPE html5>
+    <!DOCTYPE html>
 
 Supported doctypes:
 
@@ -220,13 +220,14 @@ generates:
 ### [:html, :tag, identifier, attributes, optional-sexp]
 
 HTML tag abstraction. Identifier can be a String or a Symbol. If the optional content Sexp is omitted
-the tag is closed (e.g. <br/> <img/>). The tag is also closed if the content Sexp is empty
+the tag is closed (e.g. `<br/>` `<img/>`). The tag is also closed if the content Sexp is empty
 (consists only of :multi and :newline expressions) and the tag is registered as auto-closing.
 
 Example:
     [:html, :tag, 'img', [:html, :attrs, [:html, :attr, 'src', 'image.png']]]
     [:html, :tag, 'p', [:multi], [:static, 'Content']]
 generates:
+    
     <img src="image.png"/>
     <p>Content</p>
 

data/Gemfile

@@ -1,3 +1,2 @@
 source 'https://rubygems.org/'
 gemspec
-

data/README.md

@@ -1,7 +1,7 @@
 Temple
 ======
 
-[![Build Status](https://secure.travis-ci.org/judofyr/temple.png?branch=master)](http://travis-ci.org/judofyr/temple) [![Dependency Status](https://gemnasium.com/judofyr/temple.png?travis)](https://gemnasium.com/judofyr/temple) [![Code Climate](https://codeclimate.com/github/judofyr/temple.png)](https://codeclimate.com/github/judofyr/temple)
+[![test](https://github.com/judofyr/temple/actions/workflows/test.yml/badge.svg)](https://github.com/judofyr/temple/actions/workflows/test.yml) [![Code Climate](https://codeclimate.com/github/judofyr/temple.svg)](https://codeclimate.com/github/judofyr/temple) [![Gem Version](https://badge.fury.io/rb/temple.svg)](https://rubygems.org/gems/temple) [![Yard Docs](https://img.shields.io/badge/yard-docs-blue.svg)](http://rubydoc.info/gems/temple/frames)
 
 Temple is an abstraction and a framework for compiling templates to pure Ruby.
 It's all about making it easier to experiment, implement and optimize template
@@ -23,6 +23,7 @@ Links
 * API documentation:
     * Latest Gem: <http://rubydoc.info/gems/temple/frames>
     * GitHub master: <http://rubydoc.info/github/judofyr/temple/master/frames>
+* Abstractions: <http://github.com/judofyr/temple/blob/master/EXPRESSIONS.md>
 
 Overview
 --------
@@ -123,7 +124,7 @@ continue to use the HTML abstraction. Maybe you even want to write your
 compiler in another language? Sexps are easily serialized and if you don't
 mind working across processes, it's not a problem at all.
 
-All abstractions used by Temple are documented in {file:EXPRESSIONS.md EXPRESSIONS}.
+All abstractions used by Temple are documented in [EXPRESSIONS.md](EXPRESSIONS.md).
 
 Compilers
 ---------
@@ -195,8 +196,8 @@ When you have a chain of a parsers, some filters and a generator you can finally
 
 ```ruby
  class MyEngine < Temple::Engine
-   # First run MyParser, passing the :strict option
-   use MyParser, :strict
+   # First run MyParser
+   use MyParser
 
    # Then a custom filter
    use MyFilter
@@ -207,10 +208,10 @@ When you have a chain of a parsers, some filters and a generator you can finally
    filter :DynamicInliner
 
    # Finally the generator
-   generator :ArrayBuffer, :buffer
+   generator :ArrayBuffer
  end
 
- engine = MyEngine.new(:strict => "For MyParser")
+ engine = MyEngine.new(strict: "For MyParser")
  engine.call(something)
 ```
 
@@ -227,7 +228,7 @@ Rails.
  require 'tilt'
 
  # Create template class MyTemplate and register your file extension
- MyTemplate = Temple::Templates::Tilt(MyEngine, :register_as => 'ext')
+ MyTemplate = Temple::Templates::Tilt(MyEngine, register_as: 'ext')
 
  Tilt.new('example.ext').render     # => Render a file
  MyTemplate.new { "String" }.render # => Render a string
@@ -236,7 +237,7 @@ Rails.
 Installation
 ------------
 
-You need Ruby 1.8.7 or Ruby 1.9.2 to work with Temple. Temple is published as a Ruby Gem which can be installed
+You need at least Ruby 1.9.3 to work with Temple. Temple is published as a Ruby Gem which can be installed
 as following:
 
 ```bash
@@ -246,10 +247,13 @@ as following:
 Engines using Temple
 --------------------
 
-* [Slim](http://github.com/slim-template/slim)
-* [Sal](http://github.com/stonean/sal.rb)
+* [Slim](https://github.com/slim-template/slim)
+* [Hamlit](https://github.com/k0kubun/hamlit)
+* [Faml](https://github.com/eagletmt/faml)
+* [Sal](https://github.com/stonean/sal.rb)
 * [Temple-Mustache (Example implementation)](https://github.com/minad/temple-mustache)
 * Temple ERB example implementation (Temple::ERB::Template)
+* [WLang](https://github.com/blambeau/wlang)
 
 Acknowledgements
 ----------------

data/Rakefile

@@ -1,15 +1,8 @@
-require 'rake/testtask'
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
 
-task :default => :test
-task :test do
-  sh "bacon -Ilib -Itest --automatic --quiet"
-end
-
-#Rake::TestTask.new(:test) do |t|
-#  t.libs << 'lib' << 'test'
-#  t.pattern = 'test/**/test_*.rb'
-#  t.verbose = false
-#end
+RSpec::Core::RakeTask.new(:spec)
+task default: :spec
 
 begin
   require 'rcov/rcovtask'

data/lib/temple/engine.rb

@@ -24,7 +24,7 @@ module Temple
   #     replace :ArrayBuffer, Temple::Generators::RailsOutputBuffer
   #   end
   #
-  #   engine = MyEngine.new(:strict => "For MyParser")
+  #   engine = MyEngine.new(strict: "For MyParser")
   #   engine.call(something)
   #
   # @api public
@@ -33,7 +33,7 @@ module Temple
     include Mixins::EngineDSL
     extend  Mixins::EngineDSL
 
-    define_options :file, :streaming, :buffer
+    define_options :file, :streaming, :buffer, :save_buffer
 
     attr_reader :chain
 
@@ -57,7 +57,11 @@ module Temple
     end
 
     def call_chain
-      @call_chain ||= @chain.map {|name, constructor| constructor.call(self) }.compact
+      @call_chain ||= @chain.map do |name, constructor|
+        f = constructor.call(self)
+        raise "Constructor #{name} must return callable object" if f && !f.respond_to?(:call)
+        f
+      end.compact
     end
   end
 end

data/lib/temple/erb/engine.rb

@@ -5,10 +5,12 @@ module Temple
     # @api public
     class Engine < Temple::Engine
       use Temple::ERB::Parser
-      use Temple::ERB::Trimming, :trim_mode
-      filter :Escapable, :use_html_safe, :disable_escape
+      use Temple::ERB::Trimming
+      filter :Escapable
+      filter :StringSplitter
+      filter :StaticAnalyzer
       filter :MultiFlattener
-      filter :DynamicInliner
+      filter :StaticMerger
       generator :ArrayBuffer
     end
   end

data/lib/temple/erb/parser.rb

@@ -27,7 +27,7 @@ module Temple
             when '#'
               result << [:code, "\n" * code.count("\n")]
             when /=/
-              result << [:escape, indicator.size <= 1, [:dynamic, code]]
+              result << [:escape, indicator.size == 2, [:dynamic, code]]
             else
               result << [:code, code]
             end

data/lib/temple/erb/trimming.rb

@@ -1,38 +1,23 @@
 module Temple
   module ERB
-    # ERB trimming
-    # Set option :trim_mode to
-    #    <> - omit newline for lines starting with <% and ending in %>
-    #    >  - omit newline for lines ending in %>
-    #
+    # ERB trimming like in erubis
+    # Deletes spaces around '<% %>' and leave spaces around '<%= %>'.
     # @api public
     class Trimming < Filter
-      define_options :trim_mode
+      define_options trim: true
 
       def on_multi(*exps)
-        case options[:trim_mode]
-        when '>'
-          i = 0
-          while i < exps.size
-            exps.delete_at(i + 1) if code?(exps[i]) && exps[i+1] == [:static, "\n"]
-            i += 1
+        exps = exps.each_with_index.map do |e,i|
+          if e.first == :static && i > 0 && exps[i-1].first == :code
+            [:static, e.last.lstrip]
+          elsif e.first == :static && i < exps.size-1 && exps[i+1].first == :code
+            [:static, e.last.rstrip]
+          else
+            e
           end
-        when '<>'
-          i = 0
-          while i < exps.size
-            exps.delete_at(i + 1) if code?(exps[i]) && exps[i+1] == [:static, "\n"] &&
-                                     (!exps[i-1] || (exps[i-1] == [:newline]))
-            i += 1
-          end
-        end
+        end if options[:trim]
         [:multi, *exps]
       end
-
-      protected
-
-      def code?(exp)
-        exp[0] == :escape || exp[0] == :code
-      end
     end
   end
 end

data/lib/temple/filters/ambles.rb

@@ -0,0 +1,21 @@
+module Temple
+  module Filters
+    class Ambles < Filter
+      define_options :preamble, :postamble
+
+      def initialize(*)
+        super
+        @preamble = options[:preamble]
+        @postamble = options[:postamble]
+      end
+
+      def call(ast)
+        ret = [:multi]
+        ret << [:static, @preamble] if @preamble
+        ret << ast
+        ret << [:static, @postamble] if @postamble
+        ret
+      end
+    end
+  end
+end

data/lib/temple/filters/encoding.rb

@@ -4,7 +4,7 @@ module Temple
     #
     # @api public
     class Encoding < Parser
-      define_options :encoding => 'utf-8'
+      define_options encoding: 'utf-8'
 
       def call(s)
         if options[:encoding] && s.respond_to?(:encoding)

data/lib/temple/filters/eraser.rb

@@ -5,7 +5,7 @@ module Temple
     # @api public
     class Eraser < Filter
       # [] is the empty type => keep all
-      define_options :keep => [[]], :erase => nil
+      define_options :erase, keep: [[]]
 
       def compile(exp)
         exp.first == :multi || (do?(:keep, exp) && !do?(:erase, exp)) ?

data/lib/temple/filters/escapable.rb

@@ -9,8 +9,8 @@ module Temple
     class Escapable < Filter
       # Activate the usage of html_safe? if it is available (for Rails 3 for example)
       define_options :escape_code,
-                     :use_html_safe => ''.respond_to?(:html_safe?),
-                     :disable_escape => false
+                     :disable_escape,
+                     use_html_safe: ''.respond_to?(:html_safe?)
 
       def initialize(opts = {})
         super

data/lib/temple/filters/remove_bom.rb

@@ -5,15 +5,8 @@ module Temple
     # @api public
     class RemoveBOM < Parser
       def call(s)
-        if s.respond_to?(:encoding)
-          if s.encoding.name =~ /^UTF-(8|16|32)(BE|LE)?/
-            s.gsub(Regexp.new("\\A\uFEFF".encode(s.encoding.name)), '')
-          else
-            s
-          end
-        else
-          s.gsub(/\A\xEF\xBB\xBF/, '')
-        end
+        return s if s.encoding.name !~ /^UTF-(8|16|32)(BE|LE)?/
+        s.gsub(Regexp.new("\\A\uFEFF".encode(s.encoding.name)), ''.freeze)
       end
     end
   end

data/lib/temple/filters/static_analyzer.rb

@@ -0,0 +1,30 @@
+module Temple
+  module Filters
+    # Convert [:dynamic, code] to [:static, text] if code is static Ruby expression.
+    class StaticAnalyzer < Filter
+      def call(exp)
+        # Optimize only when Ripper is available.
+        if ::Temple::StaticAnalyzer.available?
+          super
+        else
+          exp
+        end
+      end
+
+      def on_dynamic(code)
+        if ::Temple::StaticAnalyzer.static?(code)
+          exp = [:static, eval(code).to_s]
+
+          newlines = code.count("\n")
+          if newlines == 0
+            exp
+          else
+            [:multi, exp, *newlines.times.map { [:newline] }]
+          end
+        else
+          [:dynamic, code]
+        end
+      end
+    end
+  end
+end

data/lib/temple/filters/string_splitter.rb

@@ -0,0 +1,141 @@
+begin
+  require 'ripper'
+rescue LoadError
+end
+
+module Temple
+  module Filters
+    # Compile [:dynamic, "foo#{bar}"] to [:multi, [:static, 'foo'], [:dynamic, 'bar']]
+    class StringSplitter < Filter
+      if defined?(Ripper) && Ripper.respond_to?(:lex)
+        class << self
+          # `code` param must be valid string literal
+          def compile(code)
+            [].tap do |exps|
+              tokens = Ripper.lex(code.strip)
+              tokens.pop while tokens.last && [:on_comment, :on_sp].include?(tokens.last[1])
+
+              if tokens.size < 2
+                raise(FilterError, "Expected token size >= 2 but got: #{tokens.size}")
+              end
+              compile_tokens!(exps, tokens)
+            end
+          end
+
+          private
+
+          def strip_quotes!(tokens)
+            _, type, beg_str = tokens.shift
+            if type != :on_tstring_beg
+              raise(FilterError, "Expected :on_tstring_beg but got: #{type}")
+            end
+
+            _, type, end_str = tokens.pop
+            if type != :on_tstring_end
+              raise(FilterError, "Expected :on_tstring_end but got: #{type}")
+            end
+
+            [beg_str, end_str]
+          end
+
+          def compile_tokens!(exps, tokens)
+            beg_str, end_str = strip_quotes!(tokens)
+
+            until tokens.empty?
+              _, type, str = tokens.shift
+
+              case type
+              when :on_tstring_content
+                beg_str, end_str = escape_quotes(beg_str, end_str)
+                exps << [:static, eval("#{beg_str}#{str}#{end_str}").to_s]
+              when :on_embexpr_beg
+                embedded = shift_balanced_embexpr(tokens)
+                exps << [:dynamic, embedded] unless embedded.empty?
+              end
+            end
+          end
+
+          # Some quotes are split-unsafe. Replace such quotes with null characters.
+          def escape_quotes(beg_str, end_str)
+            case [beg_str[-1], end_str]
+            when ['(', ')'], ['[', ']'], ['{', '}']
+              [beg_str.sub(/.\z/) { "\0" }, "\0"]
+            else
+              [beg_str, end_str]
+            end
+          end
+
+          def shift_balanced_embexpr(tokens)
+            String.new.tap do |embedded|
+              embexpr_open = 1
+
+              until tokens.empty?
+                _, type, str = tokens.shift
+                case type
+                when :on_embexpr_beg
+                  embexpr_open += 1
+                when :on_embexpr_end
+                  embexpr_open -= 1
+                  break if embexpr_open == 0
+                end
+
+                embedded << str
+              end
+            end
+          end
+        end
+
+        def on_dynamic(code)
+          return [:dynamic, code] unless string_literal?(code)
+          return [:dynamic, code] if code.include?("\n")
+
+          temple = [:multi]
+          StringSplitter.compile(code).each do |type, content|
+            case type
+            when :static
+              temple << [:static, content]
+            when :dynamic
+              temple << on_dynamic(content)
+            end
+          end
+          temple
+        end
+
+        private
+
+        def string_literal?(code)
+          return false if SyntaxChecker.syntax_error?(code)
+
+          type, instructions = Ripper.sexp(code)
+          return false if type != :program
+          return false if instructions.size > 1
+
+          type, _ = instructions.first
+          type == :string_literal
+        end
+
+        class SyntaxChecker < Ripper
+          class ParseError < StandardError; end
+
+          def self.syntax_error?(code)
+            self.new(code).parse
+            false
+          rescue ParseError
+            true
+          end
+
+          private
+
+          def on_parse_error(*)
+            raise ParseError
+          end
+        end
+      else
+        # Do nothing if ripper is unavailable
+        def call(ast)
+          ast
+        end
+      end
+    end
+  end
+end

data/lib/temple/filters/validator.rb

@@ -4,7 +4,7 @@ module Temple
     #
     # @api public
     class Validator < Filter
-      define_options :grammar => Temple::Grammar
+      define_options grammar: Temple::Grammar
 
       def compile(exp)
         options[:grammar].validate!(exp)