slim 2.0.3 → 2.1.0

data/lib/slim/smart.rb

@@ -0,0 +1,8 @@
+require 'slim'
+require 'slim/smart/filter'
+require 'slim/smart/escaper'
+require 'slim/smart/parser'
+
+Slim::Engine.replace(Slim::Parser, Slim::Smart::Parser, :file, :tabsize, :shortcut, :default_tag, :attr_delims, :attr_list_delims, :code_attr_delims, :implicit_text)
+Slim::Engine.after(Slim::Smart::Parser, Slim::Smart::Filter, :smart_text, :smart_text_end_chars, :smart_text_begin_chars)
+Slim::Engine.after(Slim::Interpolation, Slim::Smart::Escaper, :smart_text_escaping)

data/lib/slim/smart/escaper.rb

@@ -0,0 +1,42 @@
+module Slim
+  module Smart
+    # Perform smart entity escaping in the
+    # expressions `[:slim, :text, type, Expression]`.
+    #
+    # @api private
+    class Escaper < ::Slim::Filter
+      define_options :smart_text_escaping => true
+
+      def call(exp)
+        if options[:smart_text_escaping]
+          super
+        else
+          exp
+        end
+      end
+
+      def on_slim_text(type, content)
+        [:escape, type != :verbatim, [:slim, :text, type, compile(content)]]
+      end
+
+      def on_static(string)
+        # Prevent obvious &foo; and &#1234; and &#x00ff; entities from escaping.
+        block = [:multi]
+        until string.empty?
+          case string
+          when /\A&(\w+|#x[0-9a-f]+|#\d+);/i
+            # Entity.
+            block << [:escape, false, [:static, $&]]
+            string = $'
+          when /\A&?[^&]*/
+            # Other text.
+            block << [:static, $&]
+            string = $'
+          end
+        end
+        block
+      end
+
+    end
+  end
+end

data/lib/slim/smart/filter.rb

@@ -0,0 +1,96 @@
+module Slim
+  module Smart
+    # Perform newline processing in the
+    # expressions `[:slim, :text, type, Expression]`.
+    #
+    # @api private
+    class Filter < ::Slim::Filter
+      define_options :smart_text => true,
+                     :smart_text_end_chars => '([{',
+                     :smart_text_begin_chars => ',.;:!?)]}'
+
+      def initialize(opts = {})
+        super
+        @active = @prepend = @append = false
+        @prepend_re = /\A#{chars_re(options[:smart_text_begin_chars])}/
+        @append_re = /#{chars_re(options[:smart_text_end_chars])}\Z/
+      end
+
+      def call(exp)
+        if options[:smart_text]
+          super
+        else
+          exp
+        end
+      end
+
+      def on_multi(*exps)
+        # The [:multi] blocks serve two purposes.
+        # On outer level, they collect the building blocks like
+        # tags, verbatim text, and implicit/explicit text.
+        # Within a text block, they collect the individual
+        # lines in [:slim, :interpolate, string] blocks.
+        #
+        # Our goal here is to decide when we want to prepend and
+        # append newlines to those individual interpolated lines.
+        # We basically want the text to come out as it was originally entered,
+        # while removing newlines next to the enclosing tags.
+        #
+        # On outer level, we choose to prepend every time, except
+        # right after the opening tag or after other text block.
+        # We also use the append flag to recognize the last expression
+        # before the closing tag, as we don't want to append newline there.
+        #
+        # Within text block, we prepend only before the first line unless
+        # the outer level tells us not to, and we append only after the last line,
+        # unless the outer level tells us it is the last line before the closing tag.
+        # Of course, this is later subject to the special begin/end characters
+        # which may further suppress the newline at the corresponding line boundary.
+        # Also note that the lines themselves are already correctly separated by newlines,
+        # so we don't have to worry about that at all.
+        block = [:multi]
+        prev = nil
+        last_exp = exps.reject{ |exp| exp.first == :newline }.last unless @active && @append
+        exps.each do |exp|
+          @append = exp.equal?(last_exp)
+          if @active
+            @prepend = false if prev
+          else
+            @prepend = prev && ( prev.first != :slim || prev[1] != :text )
+          end
+          block << compile(exp)
+          prev = exp unless exp.first == :newline
+        end
+        block
+      end
+
+      def on_slim_text(type, content)
+        @active = type != :verbatim
+        [:slim, :text, type, compile(content)]
+      ensure
+        @active = false
+      end
+
+      def on_slim_text_inline(content)
+        # Inline text is not wrapped in multi block, so set it up as if it was.
+        @prepend = false
+        @append = true
+        on_slim_text(:inline, content)
+      end
+
+      def on_slim_interpolate(string)
+        if @active
+          string = "\n" + string if @prepend && string !~ @prepend_re
+          string += "\n" if @append && string !~ @append_re
+        end
+        [:slim, :interpolate, string]
+      end
+
+      private
+
+      def chars_re(string)
+        Regexp.union(string.split(//))
+      end
+    end
+  end
+end

data/lib/slim/smart/parser.rb

@@ -0,0 +1,33 @@
+module Slim
+  module Smart
+    class Parser < ::Slim::Parser
+      define_options :implicit_text => true
+
+      def initialize(opts = {})
+        super
+        word_re = options[:implicit_text] ? LC_WORD_RE : WORD_RE
+        attr_keys = Regexp.union(@attr_shortcut.keys.sort_by {|k| -k.size } )
+        @attr_shortcut_re = /\A(#{attr_keys}+)((?:#{WORD_RE}|-)*)/
+        tag_keys = Regexp.union((@tag_shortcut.keys - @attr_shortcut.keys).sort_by {|k| -k.size } )
+        @tag_re = /\A(?:#{attr_keys}(?=-*#{WORD_RE})|#{tag_keys}|\*(?=[^\s]+)|(#{word_re}(?:#{word_re}|:|-)*#{word_re}|#{word_re}+))/
+      end
+
+      def unknown_line_indicator
+        if @line =~ /\A>( ?)/
+          # Found explicit text block.
+          @stacks.last << [:slim, :text, :explicit, parse_text_block($', @indents.last + $1.size + 1)]
+        else
+          unless options[:implicit_text]
+            syntax_error! 'Illegal shortcut' if @line =~ @attr_shortcut_re
+            super
+          end
+          # Found implicit smart text block.
+          if line = @lines.first
+            indent = ( line =~ /\A\s*\Z/ ? @indents.last + 1 : get_indent(line) )
+          end
+          @stacks.last << [:slim, :text, :implicit, parse_text_block(@line, indent)]
+        end
+      end
+    end
+  end
+end

data/lib/slim/splat/builder.rb

@@ -10,11 +10,11 @@ module Slim
       def code_attr(name, escape, value)
         if delim = @options[:merge_attrs][name]
           value = Array === value ? value.join(delim) : value.to_s
-          attr(name, escape ? Temple::Utils.escape_html(value) : value) unless value.empty?
+          attr(name, escape ? Temple::Utils.escape_html_safe(value, @options[:use_html_safe]) : value) unless value.empty?
         elsif @options[:hyphen_attrs].include?(name) && Hash === value
           hyphen_attr(name, escape, value)
         elsif value != false && value != nil
-          attr(name, value != true && escape ? Temple::Utils.escape_html(value) : value)
+          attr(name, value != true && escape ? Temple::Utils.escape_html_safe(value, @options[:use_html_safe]) : value)
         end
       end
 
@@ -69,7 +69,7 @@ module Slim
             hyphen_attr("#{name}-#{n.to_s.gsub('_', '-')}", escape, v)
           end
         else
-          attr(name, value != true && escape ? Temple::Utils.escape_html(value) : value)
+          attr(name, value != true && escape ? Temple::Utils.escape_html_safe(value, @options[:use_html_safe]) : value)
         end
       end
     end

data/lib/slim/splat/filter.rb

@@ -2,9 +2,9 @@ module Slim
   module Splat
     # @api private
     class Filter < ::Slim::Filter
-      OPTIONS = [:merge_attrs, :attr_quote, :sort_attrs, :default_tag, :hyphen_attrs, :format]
+      OPTIONS = [:merge_attrs, :attr_quote, :sort_attrs, :default_tag, :hyphen_attrs, :format, :use_html_safe]
       define_options OPTIONS
-      default_options[:hyphen_attrs] = %w(data aria)
+      set_default_options :hyphen_attrs => %w(data aria), :use_html_safe => ''.respond_to?(:html_safe?)
 
       def call(exp)
         @splat_options = nil

data/lib/slim/translator.rb

@@ -46,8 +46,8 @@ module Slim
       end
     end
 
-    def on_slim_text(exp)
-      [:slim, :text, @translator.call(exp)]
+    def on_slim_text(type, exp)
+      [:slim, :text, type, @translator.call(exp)]
     end
 
     private

data/lib/slim/version.rb

@@ -1,5 +1,5 @@
 module Slim
   # Slim version string
   # @api public
-  VERSION = '2.0.3'
+  VERSION = '2.1.0'
 end

data/slim.gemspec

@@ -18,6 +18,6 @@ Gem::Specification.new do |s|
   s.executables       = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
   s.require_paths     = %w(lib)
 
-  s.add_runtime_dependency('temple', ['~> 0.6.6'])
+  s.add_runtime_dependency('temple', ['~> 0.6.9'])
   s.add_runtime_dependency('tilt', ['>= 1.3.3', '< 2.1'])
 end

data/test/core/helper.rb

@@ -46,6 +46,8 @@ class TestSlim < MiniTest::Unit::TestCase
     raise 'Syntax error expected'
   rescue Slim::Parser::SyntaxError => ex
     assert_equal message, ex.message
+    message =~ /([^\s]+), Line (\d+)/
+    assert_backtrace ex, "#{$1}:#{$2}"
   end
 
   def assert_ruby_error(error, from, source, options = {})
@@ -58,12 +60,12 @@ class TestSlim < MiniTest::Unit::TestCase
   def assert_backtrace(ex, from)
     if defined?(RUBY_ENGINE) && RUBY_ENGINE == 'rbx'
       # HACK: Rubinius stack trace sometimes has one entry more
-      if ex.backtrace[0] !~ /^#{Regexp.escape from}:/
-        ex.backtrace[1] =~ /([^\s]+:\d+):/
+      if ex.backtrace[0] !~ /^#{Regexp.escape from}/
+        ex.backtrace[1] =~ /([^\s]+:\d+)/
         assert_equal from, $1
       end
     else
-      ex.backtrace[0] =~ /([^\s]+:\d+):/
+      ex.backtrace[0] =~ /([^\s]+:\d+)/
       assert_equal from, $1
     end
   end

data/test/core/test_code_blocks.rb

@@ -21,6 +21,17 @@ p
     assert_html '<p>Hello Ruby! Hello from within a block! Hello Ruby!</p>', source
   end
 
+  def test_render_variable_ending_with_do
+    source = %q{
+- appelido=10
+p= appelido
+- appelido
+}
+
+    assert_html '<p>10</p>', source
+  end
+
+
   def test_render_with_output_code_within_block
     source = %q{
 p

data/test/core/test_code_escaping.rb

@@ -45,10 +45,9 @@ p = "<strong>Hello World\\n, meet \\"Slim\\"</strong>.".html_safe
     end
   end
 
-  # splat ignores html_safe? for now
   def test_render_splat_with_html_safe_true
     source = %q{
-p *{ :title => '&'.html_safe }
+p *{ :title => '&amp;'.html_safe }
 }
 
     with_html_safe do
@@ -56,13 +55,24 @@ p *{ :title => '&'.html_safe }
     end
   end
 
+  def test_render_splat_with_html_safe_false
+    source = %q{
+p *{ :title => '&' }
+}
+
+    with_html_safe do
+      assert_html "<p title=\"&amp;\"></p>", source, :use_html_safe => true
+    end
+  end
+
+
   def test_render_attribute_with_html_safe_true
     source = %q{
-p title=('&'.html_safe)
+p title=('&amp;'.html_safe)
 }
 
     with_html_safe do
-      assert_html "<p title=\"&\"></p>", source, :use_html_safe => true
+      assert_html "<p title=\"&amp;\"></p>", source, :use_html_safe => true
     end
   end
 

data/test/core/test_embedded_engines.rb

@@ -69,6 +69,17 @@ creole:
     assert_html "<h1>head1</h1><h2>head2</h2>", source
   end
 
+  def test_render_with_creole_one_line
+    source = %q{
+creole: Hello **world**,
+  we can write one-line embedded markup now!
+  = Headline
+  Text
+.nested: creole: **Strong**
+}
+    assert_html '<p>Hello <strong>world</strong>, we can write one-line embedded markup now!</p><h1>Headline</h1><p>Text</p><div class="nested"><p><strong>Strong</strong></p></div>', source
+  end
+
   def test_render_with_org
     # HACK: org-ruby registers itself in Tilt
     require 'org-ruby'
@@ -113,6 +124,21 @@ p Hi
     assert_html %{<script type="text/javascript">$(function() {});\n\n\nalert('hello')</script><p>Hi</p>}, source
   end
 
+  def test_render_with_opal
+    begin
+      # HACK: org-ruby registers itself in Tilt
+      require 'opal'
+    rescue LoadError
+      return
+    end
+
+    source = %q{
+opal:
+  puts 'hello from opal'
+}
+    assert_match '$puts("hello from opal")', render(source)
+  end
+
   def test_render_with_javascript_with_tabs
     source = "javascript:\n\t$(function() {});\n\talert('hello')\np Hi"
     assert_html "<script type=\"text/javascript\">$(function() {});\nalert('hello')</script><p>Hi</p>", source

data/test/core/test_html_structure.rb

@@ -14,6 +14,15 @@ html
     assert_html '<html><head><title>Simple Test Title</title></head><body><p>Hello World, meet Slim.</p></body></html>', source
   end
 
+  def test_relaxed_indentation_of_first_line
+    source = %q{
+  p
+    .content
+}
+
+    assert_html "<p><div class=\"content\"></div></p>", source
+  end
+
   def test_html_tag_with_text_and_empty_line
     source = %q{
 p Hello
@@ -209,6 +218,17 @@ p#test class="paragraph" This is line one.
     assert_html "<p class=\"paragraph\" id=\"test\">This is line one.\nThis is line two.</p>", source
   end
 
+  def test_relaxed_text_indentation
+    source = %q{
+p
+  | text block
+   text
+    line3
+}
+
+    assert_html "<p>text block\ntext\n line3</p>", source
+  end
+
   def test_output_code_with_leading_spaces
     source = %q{
 p= hello_world
@@ -311,6 +331,25 @@ closed/
     assert_html '<closed />', source, :format => :xhtml
   end
 
+  def test_custom_attr_list_delims_option
+    source = %q{
+p { foo="bar" x=(1+1) }
+p < x=(1+1) > Hello
+}
+
+    assert_html '<p foo="bar" x="2"></p><p>< x=(1+1) > Hello</p>', source
+    assert_html '<p foo="bar" x="2"></p><p>< x=(1+1) > Hello</p>', source, :attr_list_delims => {'{' => '}'}
+    assert_html '<p>{ foo="bar" x=(1+1) }</p><p x="2">Hello</p>', source, :attr_list_delims => {'<' => '>'}, :code_attr_delims => { '(' => ')' }
+  end
+
+  def test_closed_tag
+    source = %q{
+closed/
+}
+
+    assert_html '<closed />', source, :format => :xhtml
+  end
+
   def test_attributs_with_parens_and_spaces
     source = %q{label{ for='filter' }= hello_world}
     assert_html '<label for="filter">Hello World from @env</label>', source

data/test/core/test_parser_errors.rb

@@ -19,40 +19,23 @@ doctype 5
     assert_syntax_error "Unexpected indentation\n  (__TEMPLATE__), Line 3, Column 2\n    div Invalid\n    ^\n", source
   end
 
-  def test_unexpected_text_indentation
+  def test_malformed_indentation
     source = %q{
 p
-  | text block
-   text
-}
-
-    assert_syntax_error "Text line not indented deep enough.\nThe first text line defines the necessary text indentation.\n  (__TEMPLATE__), Line 4, Column 3\n    text\n    ^\n", source
-  end
-
-  def test_unexpected_text_indentation_in_tag
-    source = %q{
-ul
-  li List1
-    ul
-      li a
-      li b
-  li List2
-    ul
-      li a
-      li b
+  div Valid
+ div Invalid
 }
 
-    assert_syntax_error "Text line not indented deep enough.\nThe first text line defines the necessary text indentation.\nAre you trying to nest a child tag in a tag containing text? Use | for the text block!\n  (__TEMPLATE__), Line 4, Column 4\n    ul\n    ^\n", source
+    assert_syntax_error "Malformed indentation\n  (__TEMPLATE__), Line 4, Column 1\n    div Invalid\n    ^\n", source
   end
 
-  def test_malformed_indentation
+  def test_malformed_indentation2
     source = %q{
-p
   div Valid
  div Invalid
 }
 
-    assert_syntax_error "Malformed indentation\n  (__TEMPLATE__), Line 4, Column 1\n    div Invalid\n    ^\n", source
+    assert_syntax_error "Malformed indentation\n  (__TEMPLATE__), Line 3, Column 1\n    div Invalid\n    ^\n", source
   end
 
   def test_unknown_line_indicator
@@ -76,13 +59,13 @@ p
     assert_syntax_error "Expected closing delimiter )\n  (__TEMPLATE__), Line 3, Column 33\n    img(src=\"img.jpg\" title={title}\n                                   ^\n", source
   end
 
-  def test_expected_closing_quote
+  def test_missing_quote_unexpected_end
     source = %q{
 p
   img(src="img.jpg
 }
 
-    assert_syntax_error "Expected closing quote \"\n  (__TEMPLATE__), Line 3, Column 18\n    img(src=\"img.jpg\n                    ^\n", source
+assert_syntax_error "Unexpected end of file\n  (__TEMPLATE__), Line 3, Column 0\n    \n    ^\n", source
   end
 
   def test_expected_closing_attribute_delimiter