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

slim 0.6.1 → 0.7.0.beta.2

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 (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