RubyGems - slim - Versions diffs - 0.6.1 → 0.7.0.beta.2 - Mend

slim 0.6.1 → 0.7.0.beta.2

Files changed (42) hide show

data/.gitignore +8 -0
data/Gemfile +1 -6
data/Gemfile.lock +20 -16
data/README.md +137 -90
data/Rakefile +9 -37
data/benchmarks/run.rb +63 -0
data/benchmarks/src/complex.erb +23 -0
data/benchmarks/src/complex.haml +18 -0
data/benchmarks/src/complex.slim +18 -0
data/benchmarks/src/complex_view.rb +17 -0
data/lib/slim.rb +15 -11
data/lib/slim/compiler.rb +71 -137
data/lib/slim/embedded_engine.rb +108 -0
data/lib/slim/end_inserter.rb +57 -0
data/lib/slim/engine.rb +16 -14
data/lib/slim/filter.rb +44 -0
data/lib/slim/helpers.rb +37 -0
data/lib/slim/parser.rb +355 -0
data/lib/slim/rails.rb +2 -2
data/lib/slim/template.rb +18 -0
data/lib/slim/version.rb +3 -0
data/slim.gemspec +26 -66
data/test/helper.rb +32 -4
data/test/slim/test_code_blocks.rb +33 -0
data/test/slim/test_code_escaping.rb +69 -0
data/test/slim/test_code_evaluation.rb +199 -0
data/test/slim/test_code_helpers.rb +12 -0
data/test/slim/test_code_output.rb +116 -0
data/test/slim/test_code_structure.rb +84 -0
data/test/slim/test_embedded_engines.rb +55 -0
data/test/slim/test_html_escaping.rb +32 -0
data/test/slim/test_html_structure.rb +181 -0
data/test/slim/test_parser_errors.rb +98 -0
data/test/slim/test_slim_template.rb +128 -0
data/vim/slim.vim +33 -0
data/vim/test.slim +27 -0
metadata +127 -34
data/lib/slim/optimizer.rb +0 -70
data/readme.html +0 -159
data/test/slim/test_compiler.rb +0 -389
data/test/slim/test_engine.rb +0 -458
data/test/test_slim.rb +0 -4

data/benchmarks/run.rb ADDED Viewed

@@ -0,0 +1,63 @@
+#!/usr/bin/env ruby
+$: << File.join(File.dirname(__FILE__), '..', 'lib') << File.join(File.dirname(__FILE__), 'src')
+require 'slim'
+require 'complex_view'
+require 'benchmark'
+require 'ostruct'
+require 'erubis'
+require 'erb'
+require 'haml'
+class SlimBenchmarks
+  def initialize(iterations)
+    @iterations = (iterations || 1000).to_i
+    @benches    = []
+    tpl_erb  = File.read(File.dirname(__FILE__) + '/src/complex.erb')
+    tpl_haml = File.read(File.dirname(__FILE__) + '/src/complex.haml')
+    tpl_slim = File.read(File.dirname(__FILE__) + '/src/complex.slim')
+    view  = ComplexView.new
+    eview = OpenStruct.new(:header => view.header, :item => view.item).instance_eval{ binding }
+    erb         = ERB.new(tpl_erb)
+    erubis      = Erubis::Eruby.new(tpl_erb)
+    fast_erubis = Erubis::FastEruby.new(tpl_erb)
+    haml        = Haml::Engine.new(tpl_haml)
+    haml_ugly   = Haml::Engine.new(tpl_haml, :ugly => true)
+    slim        = Slim::Engine.new(tpl_slim)
+    bench('erb')                  { ERB.new(tpl_erb).result(eview) }
+    bench('erubis')               { Erubis::Eruby.new(tpl_erb).result(eview) }
+    bench('fast erubis')          { Erubis::Eruby.new(tpl_erb).result(eview) }
+    bench('slim')                 { Slim::Engine.new(tpl_slim).render(view) }
+    bench('haml')                 { Haml::Engine.new(tpl_haml).render(view) }
+    bench('haml ugly')            { Haml::Engine.new(tpl_haml, :ugly => true).render(view) }
+    bench('erb (cached)')         { erb.result(eview) }
+    bench('erubis (cached)')      { erubis.result(eview) }
+    bench('fast erubis (cached)') { fast_erubis.result(eview) }
+    bench('slim (cached)')        { slim.render(view) }
+    bench('haml (cached)')        { haml.render(view) }
+    bench('haml ugly (cached)')   { haml_ugly.render(view) }
+  end
+  def run
+    puts "#{@iterations} Iterations"
+    Benchmark.bmbm do |x|
+      @benches.each do |name, block|
+        x.report name.to_s do
+          @iterations.to_i.times { block.call }
+        end
+      end
+    end
+  end
+  def bench(name, &block)
+    @benches.push([name, block])
+  end
+end
+SlimBenchmarks.new(ARGV[0]).run

data/benchmarks/src/complex.erb ADDED Viewed

@@ -0,0 +1,23 @@
+<!DOCTYPE HTML>
+<html>
+  <head>
+    <title>Simple Benchmark</title>
+  </head>
+  <body>
+    <h1><%= header %></h1>
+    <% unless item.empty? %>
+      <ul>
+      <% for i in item %>
+        <% if i[:current] %>
+          <li><strong><%= i[:name] %></strong></li>
+        <% else %>
+          <li><a href="<%= i[:url] %>"><%= i[:name] %></a></li>
+        <% end %>
+      <% end %>
+      </ul>
+    <% else %>
+      <p>The list is empty.</p>
+    <% end %>
+  </body>
+</html>

data/benchmarks/src/complex.haml ADDED Viewed

@@ -0,0 +1,18 @@
+!!! html
+%body
+  %head
+    %title Simple Benchmark
+  %body
+    %h1= header
+    - unless item.empty?
+      %ul
+        - for i in item
+          - if i[:current]
+            %li
+              %strong= i[:name]
+          - else
+            %li
+              %a{:href => i[:url]}= i[:name]
+    - else
+      %p The list is empty.

data/benchmarks/src/complex.slim ADDED Viewed

@@ -0,0 +1,18 @@
+! doctype html
+body
+  head
+    title Simple Benchmark
+  body
+    h1 == header
+    - unless item.empty?
+      ul
+        - for i in item
+          - if i[:current]
+            li
+              strong == i[:name]
+          - else
+            li
+              a href="#{i[:url]}" == i[:name]
+    - else
+      p The list is empty.

data/benchmarks/src/complex_view.rb ADDED Viewed

@@ -0,0 +1,17 @@
+require 'tilt'
+class ComplexView
+  include Tilt::CompileSite
+  def header
+    "Colors"
+  end
+  def item
+    items = []
+    items << { :name => 'red', :current => true, :url => '#red' }
+    items << { :name => 'green', :current => false, :url => '#green' }
+    items << { :name => 'blue', :current => false, :url => '#blue' }
+    items
+  end
+end

data/lib/slim.rb CHANGED Viewed

@@ -1,20 +1,24 @@
 # encoding: utf-8
-$:.unshift File.dirname(__FILE__)
+require 'temple'
+require 'tilt'
-require 'bundler/setup'
-require 'escape_utils'
+require 'slim/helpers'
+require 'slim/parser'
+require 'slim/filter'
+require 'slim/end_inserter'
+require 'slim/embedded_engine'
 require 'slim/compiler'
 require 'slim/engine'
+require 'slim/template'
-module Slim
-  class << self
-    def version
-      '0.6.1'
-    end
+begin
+  require 'escape_utils'
+rescue LoadError
+end
-    def escape_html(html)
-      EscapeUtils.escape_html(html.to_s)
-    end
+module Slim
+  def self.version
+    Slim::VERSION
   end
 end

data/lib/slim/compiler.rb CHANGED Viewed

@@ -1,161 +1,95 @@
-# encoding: utf-8
+module Slim
+  # Compiles Slim expressions into Temple::HTML expressions.
+  class Compiler < Filter
+    def on_text(string)
+      if string.include?('#{')
+        [:dynamic, escape_interpolation(string)]
+      else
+        [:static, string]
+      end
+    end
-require 'slim/optimizer'
+    def on_control(code, content)
+      [:multi,
+        [:block, code],
+        compile(content)]
+    end
-module Slim
-  module Compiler
-    include Optimizer
-    AUTOCLOSED         = %w{meta img link br hr input area param col base}
-    CONTROL_WORDS      = %w{if unless do}
-    ELSE_CONTROL_WORDS = %w{else elsif}
-    REGEX_LINE_PARSER = /^(\s*)(!?`?\|?-?=?\/?\w*)\(?((\S*[#.]\S+)?(?:\s*(?:\w|-)*="[^=]+")*)?\)?(.*)/
-    REGEX_LINE_CONTAINS_OUTPUT_CODE       = /^\s*=(.*)/
-    REGEX_LINE_CONTAINS_METHOD_DETECTED   = /^((?:(?!#{CONTROL_WORDS * '\b|'}\b).)*)/
-    REGEX_METHOD_HAS_NO_PARENTHESES       = /^\w+\s+\S+/
-    REGEX_CODE_BLOCK_DETECTED             = / do ?.*$/
-    REGEX_CODE_CONTROL_WORD_DETECTED      = /(?:\s|(\())(#{CONTROL_WORDS * '|'})\b\s?(.*)$/
-    REGEX_CODE_ELSE_CONTROL_WORD_DETECTED = /^#{ELSE_CONTROL_WORDS * '\b|'}\b/
-    REGEX_FIND_HTML_ATTR_ID               = /#([^.\s]+)/
-    REGEX_FIND_HTML_ATTR_CLASSES          = /\.([^#\s]+)/
-    def compile
-      @_buffer    = ['_buf = [];']
-      in_text     = false
-      enders      = []
-      text_indent = last_indent = -1
-      @template.each_line do |line|
-        line.chomp!
-        line.rstrip!
-        if line.empty?
-          @_buffer << '_buf << "<br/>";' if in_text
-          next
-        end
+    def on_embedded(engine, *body)
+      EmbeddedEngine[engine].compile(body)
+    end
-        line =~ REGEX_LINE_PARSER
+    # why is escaping not handled by temple?
+    def on_output(escape, code, content)
+      if empty_exp?(content)
+        [:dynamic, escape ? escape_code(code) : code]
+      else
+        on_output_block(escape, code, content)
+      end
+    end
-        indent = $1.to_s.length
+    def on_output_block(escape, code, content)
+      tmp1, tmp2 = tmp_var, tmp_var
-        if in_text && indent > text_indent
-          spaces = indent - text_indent
-          @_buffer << "_buf << \"#{(' '*(spaces - 1)) + line.lstrip}\";"
-          next
-        end
+      [:multi,
+        # Capture the result of the code in a variable. We can't do
+        # `[:dynamic, code]` because it's probably not a complete
+        # expression (which is a requirement for Temple).
+        [:block, "#{tmp1} = #{code}"],
-        marker         = $2
-        attrs          = $3
-        shortcut_attrs = $4
-        string         = $5
-        # Remove the first space, but allow people to pad if they want.
-        string.slice!(0) if string =~ /^\s/
-        line_type = case marker
-                    when '`', '|' then :text
-                    when '-'      then :control_code
-                    when '='      then :output_code
-                    when '!'      then :declaration
-                    when '/'      then next # simply ignore any ruby code comments
-                    else :markup
-                    end
-        unless attrs.empty?
-          normalize_attributes!(attrs) if shortcut_attrs
-          attrs.gsub!('"', '\"')
-          attrs = " #{attrs}" unless attrs =~ /^\s/
-        end
+        # Capture the content of a block in a separate buffer. This means
+        # that `yield` will not output the content to the current buffer,
+        # but rather return the output.
+        [:capture, tmp2,
+         compile(content)],
-        unless indent > last_indent
-          begin
-            break if enders.empty?
-            continue_closing = true
-            ender, ender_indent = enders.pop
-            unless ender_indent < indent || ender_indent == indent && string =~ REGEX_CODE_ELSE_CONTROL_WORD_DETECTED
-              @_buffer << ender
-            else
-              enders << [ender, ender_indent]
-              continue_closing = false
-            end
-          end while continue_closing == true
-        end
+        # Make sure that `yield` returns the output.
+        [:block, tmp2],
-        last_indent = indent
-        case line_type
-        when :markup
-          if AUTOCLOSED.include?(marker)
-            @_buffer << "_buf << \"<#{marker}#{attrs}/>\";"
-          else
-            # prepends "div" to the shortcut form of attrs if no marker is given
-            marker = 'div' if shortcut_attrs && marker.empty?
-            enders   << ["_buf << \"</#{marker}>\";", indent]
-            @_buffer << "_buf << \"<#{marker}#{attrs}>\";"
-          end
-          if string =~ REGEX_LINE_CONTAINS_OUTPUT_CODE
-            @_buffer << "_buf << #{parse_string($1.strip)};"
-          else
-            @_buffer << "_buf << \"#{string}\";" unless string.empty?
-          end
-        when :text
-          in_text     = true
-          text_indent = indent
-          @_buffer << "_buf << \"#{string}\";" unless string.empty?
-        when :control_code
-          enders   << ['end;', indent] unless enders.detect{|e| e[0] == 'end;' && e[1] == indent}
-          @_buffer << "#{string};"
-        when :output_code
-          enders   << ['end;', indent] if string =~ REGEX_CODE_BLOCK_DETECTED
-          @_buffer << "_buf << #{parse_string(string)};"
-        when :declaration
-          @_buffer << "_buf << \"<!#{string}>\";"
-        else
-          raise NotImplementedError.new("Don't know how to parse line: #{line}")
-        end
-      end # template iterator
+        # Close the block.
+        [:block, "end"],
-      enders.reverse_each do |t|
-        @_buffer << t[0]
+        # Output the content.
+        on_output(escape, tmp1, [:multi])]
+    end
+    def on_directive(type)
+      case type
+      when /^doctype/
+        [:html, :doctype, $'.strip]
+      else
       end
+    end
-      @_buffer << "_buf.join;"
+    def on_tag(name, attrs, content)
+      attrs = attrs.inject([:html, :attrs]) do |m, (key, value)|
+        if value.include?('#{')
+          value = [:dynamic, escape_interpolation(value)]
+        else
+          value = [:static, value]
+        end
+        m << [:html, :basicattr, [:static, key], value]
+      end
-      @compiled  = @_buffer.join
-      @optimized = optimize!
+      [:html, :tag, name, attrs, compile(content)]
     end
     private
-    def parse_string(string)
-      if string =~ REGEX_LINE_CONTAINS_OUTPUT_CODE
-        $1.strip
-      else
-        parenthesesify_method!(string)  if string =~ REGEX_METHOD_HAS_NO_PARENTHESES
-        wraps_with_slim_escape!(string) unless string =~ REGEX_CODE_BLOCK_DETECTED
-        string.strip
+    def escape_interpolation(string)
+      string.gsub!(/(.?)\#\{(.*?)\}/) do
+        $1 == '\\' ? $& : "#{$1}#\{#{escape_code($2)}}"
       end
+      '"%s"' % string
     end
-    # adds a pair of parentheses to the method
-    def parenthesesify_method!(string)
-      string.sub!(' ', '(') && string.sub!(REGEX_CODE_CONTROL_WORD_DETECTED, '\1) \2 \3') || string << ')'
-    end
-    # escapes the string
-    def wraps_with_slim_escape!(string)
-      string.sub!(REGEX_LINE_CONTAINS_METHOD_DETECTED, 'Slim.escape_html(\1)')
+    def escape_code(param)
+      "Slim::Helpers.escape_html#{@options[:use_html_safe] ? '_safe' : ''}((#{param}))"
     end
-    # converts 'p#hello.world.mate' to 'p id="hello" class="world mate"'
-    def normalize_attributes!(string)
-      string.sub!(REGEX_FIND_HTML_ATTR_ID, ' id="\1"')
-      string.sub!(REGEX_FIND_HTML_ATTR_CLASSES, ' class="\1"') && string.gsub!('.', ' ')
+    def tmp_var
+      @tmp_var ||= 0
+      "_slimtmp#{@tmp_var += 1}"
     end
   end
 end

data/lib/slim/embedded_engine.rb ADDED Viewed

@@ -0,0 +1,108 @@
+module Slim
+  class EmbeddedEngine
+    @engines = {}
+    attr_reader :options
+    def initialize(options)
+      @options = options
+    end
+    def self.[](name)
+      engine = @engines[name.to_s]
+      raise "Invalid embedded engine #{name}" if !engine
+      engine.dup
+    end
+    def self.register(name, klass, options = {})
+      options.merge!(:name => name.to_s)
+      @engines[name.to_s] = klass.new(options)
+    end
+    def collect_text(body)
+      body.inject('') do |text, exp|
+        if exp[0] == :slim && exp[1] == :text
+          text << exp[2]
+        elsif exp[0] == :newline
+          text << "\n"
+        end
+        text
+      end
+    end
+    class TiltEngine < EmbeddedEngine
+      # Code to collect local variables
+      COLLECT_LOCALS = %q{eval('{' + local_variables.select {|v| v[0] != ?_ }.map {|v| ":#{v}=>#{v}" }.join(',') + '}')}
+      def compile(body)
+        text = collect_text(body)
+        engine = Tilt[options[:name]]
+        if options[:precompiled]
+          # Wrap precompiled code in proc, local variables from out the proc are accessible
+          # WARNING: This is a bit of a hack. Tilt::Engine#precompiled is protected
+          precompiled = engine.new { text }.send(:precompiled, {}).first
+          [:dynamic, "proc { #{precompiled} }.call"]
+        elsif options[:dynamic]
+          # Fully dynamic evaluation of the template during runtime (Slow and uncached)
+          [:dynamic, "#{engine.name}.new { #{text.inspect} }.render(self, #{COLLECT_LOCALS})"]
+        elsif options[:interpolate]
+          # Static template with interpolated ruby code
+          [:dynamic, '"%s"' % engine.new { text }.render]
+        else
+          # Static template
+          [:static, engine.new { text }.render]
+        end
+      end
+    end
+    class TagEngine < EmbeddedEngine
+      def compile_text(body)
+        body.inject([:multi]) do |block, exp|
+          block << (exp[0] == :slim && exp[1] == :text ? [:static, exp[2]] : exp)
+        end
+      end
+      def compile(body)
+        attrs = [:html, :attrs]
+        options[:attributes].each do |key, value|
+          attrs << [:html, :basicattr, [:static, key.to_s], [:static, value.to_s]]
+        end
+        [:html, :tag, options[:tag], attrs, compile_text(body)]
+      end
+    end
+    class RubyEngine < EmbeddedEngine
+      def compile(body)
+        [:block, collect_text(body)]
+      end
+    end
+    # These engines are executed at compile time, embedded ruby is interpolated
+    register :markdown, TiltEngine, :interpolate => true
+    register :textile, TiltEngine, :interpolate => true
+    register :rdoc, TiltEngine, :interpolate => true
+    # These engines are executed at compile time
+    register :sass, TiltEngine
+    register :less, TiltEngine
+    register :coffee, TiltEngine
+    # These engines are precompiled, code is embedded
+    register :erb, TiltEngine, :precompiled => true
+    register :haml, TiltEngine, :precompiled => true
+    register :nokogiri, TiltEngine, :precompiled => true
+    register :builder, TiltEngine, :precompiled => true
+    # These engines are completely executed at runtime (Usage not recommended, no caching!)
+    register :liquid, TiltEngine, :dynamic => true
+    register :radius, TiltEngine, :dynamic => true
+    register :markaby, TiltEngine, :dynamic => true
+    # Embedded javascript/css
+    register :javascript, TagEngine, :tag => 'script', :attributes => { :type => 'text/javascript' }
+    register :css, TagEngine, :tag => 'style', :attributes => { :type => 'text/css' }
+    # Embedded ruby code
+    register :ruby, RubyEngine
+  end
+end