slim 0.7.1 → 0.7.2

data/Gemfile.lock

@@ -1,8 +1,8 @@
 PATH
   remote: .
   specs:
-    slim (0.7.0)
-      temple (~> 0.1.4)
+    slim (0.7.2)
+      temple (~> 0.1.5)
       tilt (~> 1.1)
 
 GEM
@@ -17,7 +17,7 @@ GEM
     rake (0.8.7)
     rcov (0.9.9)
     rdiscount (1.6.5)
-    temple (0.1.4)
+    temple (0.1.5)
     tilt (1.1)
     yard (0.6.1)
 
@@ -33,6 +33,6 @@ DEPENDENCIES
   rcov
   rdiscount
   slim!
-  temple (~> 0.1.4)
+  temple (~> 0.1.5)
   tilt (~> 1.1)
   yard

data/README.md

@@ -86,8 +86,6 @@ Here's a quick example to demonstrate what a Slim template looks like:
 
 ### Line indicators
 
-__Please note that all line indicators must be followed by a space__
-
 #### `|`
 
 > The pipe tells Slim to just copy the line. It essentially escapes any processing.
@@ -148,7 +146,7 @@ __Please note that all line indicators must be followed by a space__
     body
       h1 id="headline" Welcome to my site.
 
-  Or nest it.  __Note:__ Must use a pipe or a backtick (followed by a space) to escape processing
+  Or nest it.  __Note:__ Must use a pipe or a backtick to escape processing
 
     body
       h1 id="headline"

data/extra/slim.vim

@@ -19,15 +19,42 @@ let b:ruby_no_expensive = 1
 
 " Include Ruby syntax highlighting
 syn include @slimRuby syntax/ruby.vim
+unlet! b:current_syntax
+" Include Haml syntax highlighting
+syn include @slimHaml syntax/haml.vim
+unlet! b:current_syntax
+" Include Erb syntax highlighting
+syn include @slimErb syntax/eruby.vim
+unlet! b:current_syntax
 
 " Include HTML 
 runtime! syntax/html.vim
 unlet! b:current_syntax
 
-syntax region slimHtml start="^\s*[^-=]\w" end="$" contains=htmlTagName, htmlArg, htmlString
+setlocal iskeyword+=:
+
+
+syn region slimHtml start="^\s*[^-=]\w" end="$" contains=htmlTagName,htmlArg,htmlString
+syn region slimControl start="-" end="$" contains=@slimRuby keepend
+
+syn match slimFilter /\s*\w\+:\s*/ contained
+
+syn match slimCode /^\s*[-=#.].*/ contained
+syn match slimComment /^\(\s\+\)[/].*\(\n\1\s.*\)*/ 
+syn match slimText /^\(\s\+\)[`|'].*\(\n\1\s.*\)*/ 
+
+syn match slimJs /^\(\s\+\)\<javascript:\>.*\(\n\1\s.*\)*/ contains=@htmlJavaScript,slimFilter
+syn match slimHaml /^\(\s\+\)\<haml:\>.*\(\n\1\s.*\)*/ contains=@slimHaml,slimFilter
+syn match slimHaml /^\(\s\+\)\<erb:\>.*\(\n\1\s.*\)*/ contains=@slimErb,slimFilter
+
+
+"syn match slimFilter /\s*\<javascript:\>\s*/ 
+
 
-syntax region slimControl  start="-" end="$"  contains=@slimRuby keepend
-syntax region slimOutput   start=".*=\s" end="$"  contains=@slimRuby keepend
+"contained containedin=slimJs
 
+hi def link slimText                   String
+hi def link slimComment                Comment
+hi def link slimFilter                 Special
 
 let b:current_syntax = "slim"

data/extra/test.slim

@@ -9,15 +9,21 @@ html
         alert('Hello World');
       });
 
+    haml: 
+      #someid.someclass{:this => 'test'} Content in haml
+
+    erb:
+      <%= some_method(@request) %>
+
   body
     / comment block
       with multiple lines
-
+      This is another line
     h1 = @page_title
     p#notice.message
       | Welcome to the the syntax test.
         This file is to excercise the various markup.
-
+        This is another line
     - unless @users.empty?
       table
         - for user in users do
@@ -26,6 +32,7 @@ html
     - else
       p There are no users.
 
+    / Single comment line
     #content Hello #{@user.name}! Welcome to the test page!
              Try out Slim!
 

data/lib/slim.rb

@@ -5,6 +5,8 @@ require 'slim/parser'
 require 'slim/filter'
 require 'slim/end_inserter'
 require 'slim/embedded_engine'
+require 'slim/interpolation'
+require 'slim/sections'
 require 'slim/compiler'
 require 'slim/engine'
 require 'slim/template'

data/lib/slim/command.rb

@@ -40,6 +40,14 @@ module Slim
         @options[:compile] = true
       end
 
+      opts.on('-S', '--sections', :NONE, 'Logic-less sections mode') do
+        @options[:sections] = true
+      end
+
+      opts.on('-p', '--pretty', :NONE, 'Produce pretty html') do
+        @options[:pretty] = true
+      end
+
       opts.on_tail('-h', '--help', 'Show this message') do
         puts opts
         exit
@@ -71,9 +79,13 @@ module Slim
       end
 
       if @options[:compile]
-        @options[:output].puts(Slim::Engine.new(:file => @options[:file]).compile(@options[:input].read))
+        @options[:output].puts(Slim::Engine.new(:file => @options[:file],
+                                                :pretty => @options[:pretty],
+                                                :sections => @options[:sections]).compile(@options[:input].read))
       else
-        @options[:output].puts(Slim::Template.new(@options[:file]) { @options[:input].read }.render)
+        @options[:output].puts(Slim::Template.new(@options[:file],
+                                                  :pretty => @options[:pretty],
+                                                  :sections => @options[:sections]) { @options[:input].read }.render)
       end
     end
   end

data/lib/slim/compiler.rb

@@ -2,31 +2,6 @@ module Slim
   # Compiles Slim expressions into Temple::HTML expressions.
   # @api private
   class Compiler < Filter
-    # Handle text expression `[:slim, :text, string]`
-    #
-    # @param [String] string Static text
-    # @return [Array] Compiled temple expression
-    def on_slim_text(string)
-      # Interpolate variables in text (#{variable}).
-      # Split the text into multiple dynamic and static parts.
-      block = [:multi]
-      until string.empty?
-        case string
-        when /^\\(\#\{[^\}]*\})/
-          # Escaped interpolation
-          block << [:static, $1]
-        when /^\#\{([^\}]*)\}/
-          # Interpolation
-          block << [:escape, :dynamic, $1]
-        when /^([^\#]+|\#)/
-          # Static text
-          block << [:static, $&]
-        end
-        string = $'
-      end
-      block
-    end
-
     # Handle control expression `[:slim, :control, code, content]`
     #
     # @param [String] ruby code
@@ -60,7 +35,7 @@ module Slim
     # @param [Array] content Temple expression
     # @return [Array] Compiled temple expression
     def on_slim_output_block(escape, code, content)
-      tmp1, tmp2 = tmp_var, tmp_var
+      tmp1, tmp2 = tmp_var('capture'), tmp_var('capture')
 
       [:multi,
         # Capture the result of the code in a variable. We can't do
@@ -94,32 +69,22 @@ module Slim
       end
     end
 
-    # Handle tag expression `[:slim, :tag, name, attrs, content]`
+    # Handle tag expression `[:slim, :tag, name, attrs, closed, content]`
     #
     # @param [String] name Tag name
     # @param [Array] attrs Attributes
     # @param [Array] content Temple expression
     # @return [Array] Compiled temple expression
     def on_slim_tag(name, attrs, closed, content)
-      attrs = attrs.inject([:html, :staticattrs]) do |m, (key, dynamic, value)|
-        value = if dynamic
-                  [:escape, :dynamic, value]
-                else
-                  on_slim_text(value)
-                end
-        m << [key.to_s, value]
-      end
-      [:html, :tag, name, attrs, closed, compile!(content)]
+      [:html, :tag, name, compile!(attrs), closed, compile!(content)]
     end
 
-    private
-
-    # Generate unique temporary variable name
+    # Handle tag attributes expression `[:slim, :attrs, *attrs]`
     #
-    # @return [String] Variable name
-    def tmp_var
-      @tmp_var ||= 0
-      "_slimtmp#{@tmp_var += 1}"
+    # @param [Array] attrs Attributes
+    # @return [Array] Compiled temple expression
+    def on_slim_attrs(*attrs)
+      [:html, :staticattrs, *attrs.map {|k, v| [k.to_s, compile!(v)] }]
     end
   end
 end

data/lib/slim/embedded_engine.rb

@@ -64,7 +64,7 @@ module Slim
     class TagEngine < EmbeddedEngine
       def on_slim_embedded(engine, *body)
         content = options[:engine] ? options[:engine].new.on_slim_embedded(engine, *body) : [:multi, *body]
-        [:slim, :tag, options[:tag], options[:attributes].map {|k, v| [k, false, v] }, false, content]
+        [:slim, :tag, options[:tag], [:slim, :attrs, *options[:attributes].map {|k, v| [k, [:static, v]] }], false, content]
       end
     end
 

data/lib/slim/engine.rb

@@ -2,17 +2,24 @@ module Slim
   # Slim engine which transforms slim code to executable ruby code
   # @api public
   class Engine < Temple::Engine
+    # Allow users to set default options, particularly useful in Rails' environment files.
+    # For instance, in config/environments/development.rb you probably want:
+    #     # Indent html for pretty debugging
+    #     Slim::Engine.set_default_options :pretty => true
+    #
+    set_default_options :pretty => false,
+                        :attr_wrapper => '"',
+                        :format => :html5,
+                        :id_delimiter => nil
+
     use Slim::Parser, :file
-    filter :Debugger, :debug, :prefix => 'before end insertion'
-    use Slim::EndInserter
-    filter :Debugger, :debug, :prefix => 'after end insertion'
     use Slim::EmbeddedEngine
+    use Slim::Interpolation
+    use Slim::Sections, :sections, :dictionary, :dictionary_access
+    use Slim::EndInserter
     use Slim::Compiler
-    filter :Debugger, :debug, :prefix => 'after compilation'
     filter :EscapeHTML, :use_html_safe
-    use Temple::HTML::Pretty, :format, :attr_wrapper, :id_delimiter, :id_concat, :pretty,
-                              :pretty => false, :attr_wrapper => '"', :format => :html5, :id_delimiter => nil
-    filter :Debugger, :debug, :prefix => 'after html'
+    use Temple::HTML::Pretty, :format, :attr_wrapper, :id_delimiter, :pretty
     filter :MultiFlattener
     filter :StaticMerger
     filter :DynamicInliner

data/lib/slim/filter.rb

@@ -2,6 +2,7 @@ module Slim
   # Base class for Temple filters used in Slim
   # @api private
   class Filter < Temple::Filter
+    # Dispatch on_slim_*
     temple_dispatch :slim
 
     def on_slim_control(code, content)
@@ -13,7 +14,19 @@ module Slim
     end
 
     def on_slim_tag(name, attrs, closed, content)
-      [:slim, :tag, name, attrs, closed, compile!(content)]
+      [:slim, :tag, name, compile!(attrs), closed, compile!(content)]
+    end
+
+    def on_slim_attrs(*attrs)
+      [:slim, :attrs, *attrs.map {|k, v| [k, compile!(v)] }]
+    end
+
+    # Generate unique temporary variable name
+    #
+    # @return [String] Variable name
+    def tmp_var(prefix)
+      @tmp_var ||= 0
+      "_slim#{prefix}#{@tmp_var += 1}"
     end
   end
 end

data/lib/slim/interpolation.rb

@@ -0,0 +1,30 @@
+module Slim
+  # Perform interpolation of #{var_name}
+  # @api private
+  class Interpolation < Filter
+    # Handle text expression `[:slim, :text, string]`
+    #
+    # @param [String] string Static text
+    # @return [Array] Compiled temple expression
+    def on_slim_text(string)
+      # Interpolate variables in text (#{variable}).
+      # Split the text into multiple dynamic and static parts.
+      block = [:multi]
+      until string.empty?
+        case string
+        when /^\\(\#\{[^\}]*\})/
+          # Escaped interpolation
+          block << [:static, $1]
+        when /^\#\{([^\}]*)\}/
+          # Interpolation
+          block << [:slim, :output, true, $1, [:multi]]
+        when /^([^\#]+|\#)/
+          # Static text
+          block << [:static, $&]
+        end
+        string = $'
+      end
+      block
+    end
+  end
+end

data/lib/slim/parser.rb

@@ -259,11 +259,11 @@ module Slim
       # Now we'll have to find all the attributes. We'll store these in an
       # nested array: [[name, value], [name2, value2]]. The value is a piece
       # of Ruby code.
-      attributes = []
+      attributes = [:slim, :attrs]
 
       # Find any literal class/id attributes
       while line =~ CLASS_ID_REGEX
-        attributes << [ATTR_SHORTHAND[$1], false, $2]
+        attributes << [ATTR_SHORTHAND[$1], [:static, $2]]
         line = $'
       end
 
@@ -282,11 +282,11 @@ module Slim
         if line =~ QUOTED_VALUE_REGEX
           # Value is quoted (static)
           line = $'
-          attributes << [key, false, $1[1..-2]]
+          attributes << [key, [:slim, :text, $1[1..-2]]]
         else
           # Value is ruby code
           line, value = parse_ruby_attribute(orig_line, line, lineno, delimiter)
-          attributes << [key, true, value]
+          attributes << [key, [:slim, :output, true, value, [:multi]]]
         end
       end
 

data/lib/slim/rails.rb

@@ -2,12 +2,23 @@ require 'slim'
 
 module ActionView
   module TemplateHandlers
-    # Slim handler for Rails 3
-    class SlimHandler < TemplateHandler
-      include Compilable
+    raise "Slim supports only Rails 3.x and greater, your Rails version is #{Rails::VERSION::STRING}" if Rails::VERSION::MAJOR < 3
 
-      def compile(template)
-        Slim::Engine.new(:use_html_safe => true).compile(template.source)
+    if Rails::VERSION::MAJOR == 3 && Rails::VERSION::MINOR < 1
+      # Slim handler for Rails 3.0
+      class SlimHandler < TemplateHandler
+        include Compilable
+
+        def compile(template)
+          Slim::Engine.new.compile(template.source)
+        end
+      end
+    else
+      # Slim handler for Rails 3.1 and greater
+      class SlimHandler
+        def call(template)
+          Slim::Engine.new.compile(template.source)
+        end
       end
     end
   end

data/lib/slim/sections.rb

@@ -0,0 +1,79 @@
+module Slim
+  # Handle logic-less mode
+  # This filter can be activated with the option "sections"
+  # @api private
+  class Sections < Filter
+    set_default_options :dictionary => 'self',
+                        :sections => false,
+                        :dictionary_access => :symbol # :symbol, :string
+
+    def initialize(opts = {})
+      super
+      unless [:string, :symbol].include?(@options[:dictionary_access])
+        raise "Invalid dictionary access #{@options[:dictionary_access].inspect}"
+      end
+    end
+
+    def compile(exp)
+      if options[:sections]
+        # Store the dictionary in the _slimdict variable
+        [:multi,
+         [:block, "_slimdict = #{@options[:dictionary]}"],
+         super]
+      else
+        exp
+      end
+    end
+
+    # Interpret control blocks as sections or inverted sections
+    def on_slim_control(name, content)
+      if name =~ /^!\s*(.*)/
+        on_slim_inverted_section($1, content)
+      else
+        on_slim_section(name, content)
+      end
+    end
+
+    def on_slim_inverted_section(name, content)
+      tmp = tmp_var('section')
+      [:multi,
+       [:block, "#{tmp} = #{access name}"],
+       [:block, "if !#{tmp} || #{tmp}.respond_to?(:empty) && #{tmp}.empty?"],
+                  compile!(content),
+       [:block, 'end']]
+    end
+
+    def on_slim_section(name, content)
+      content = compile!(content)
+      tmp1, tmp2 = tmp_var('dict'), tmp_var('dict')
+
+      [:multi,
+       [:block, "if #{tmp1} = #{access name}"],
+       [:block,   "if #{tmp1} == true"],
+                     content,
+       [:block,   'else'],
+       [:block,     "#{tmp1} = [#{tmp1}] if #{tmp1}.respond_to?(:has_key?) || !#{tmp1}.respond_to?(:map)"],
+       [:block,     "#{tmp2} = _slimdict"],
+       [:block,     "#{tmp1}.each do |_slimdict|"],
+                      content,
+       [:block,     'end'],
+       [:block,     "_slimdict = #{tmp2}"],
+       [:block,   'end'],
+       [:block, 'end']]
+    end
+
+    def on_slim_output(escape, name, content)
+      raise 'Output statements with content are forbidden in sections mode' if !empty_exp?(content)
+      [:slim, :output, escape, access(name), content]
+    end
+
+    def access(name)
+      case options[:dictionary_access]
+      when :symbol
+        "_slimdict[#{name.to_sym.inspect}]"
+      when :string
+        "_slimdict[#{name.to_s.inspect}]"
+      end
+    end
+  end
+end

data/lib/slim/version.rb

@@ -1,3 +1,3 @@
 module Slim
-  VERSION = "0.7.1"
+  VERSION = "0.7.2"
 end

data/slim.gemspec

@@ -1,5 +1,6 @@
 # -*- encoding: utf-8 -*-
 require File.dirname(__FILE__) + "/lib/slim/version"
+require "date"
 
 Gem::Specification.new do |s|
   s.name              = "slim"
@@ -20,7 +21,7 @@ Gem::Specification.new do |s|
   s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
   s.require_paths = ["lib"]
 
-  s.add_runtime_dependency(%q<temple>, ["~> 0.1.4"])
+  s.add_runtime_dependency(%q<temple>, ["~> 0.1.5"])
   s.add_runtime_dependency(%q<tilt>, ["~> 1.1"])
   s.add_development_dependency(%q<rake>, [">= 0.8.7"])
   s.add_development_dependency(%q<haml>, [">= 0"])

data/test/helper.rb

@@ -20,7 +20,7 @@ class TestSlim < MiniTest::Unit::TestCase
   end
 
   def render(source, options = {}, &block)
-    Slim::Template.new(options[:file], options) { source }.render(@env, &block)
+    Slim::Template.new(options[:file], options) { source }.render(options[:scope] || @env, &block)
   end
 
   def assert_html(expected, source, options = {}, &block)

data/test/slim/test_sections.rb

@@ -0,0 +1,74 @@
+require 'helper'
+
+class TestSlimLogicLess < TestSlim
+  def test_sections
+    source = %q{
+p
+ - person
+  .name = name
+}
+
+    hash = {
+      :person => [
+        { :name => 'Joe', },
+        { :name => 'Jack', }
+      ]
+    }
+
+    assert_html '<p><div class="name">Joe</div><div class="name">Jack</div></p>', source, :scope => hash, :sections => true
+  end
+
+  def test_sections_string_access
+    source = %q{
+p
+ - person
+  .name = name
+}
+
+    hash = {
+      'person' => [
+        { 'name' => 'Joe', },
+        { 'name' => 'Jack', }
+      ]
+    }
+
+    assert_html '<p><div class="name">Joe</div><div class="name">Jack</div></p>', source, :scope => hash, :sections => true, :dictionary_access => :string
+  end
+
+  def test_flag_section
+    source = %q{
+p
+ - show_person
+   - person
+    .name = name
+ - show_person
+   | shown
+}
+
+    hash = {
+      :show_person => true,
+      :person => [
+        { :name => 'Joe', },
+        { :name => 'Jack', }
+      ]
+    }
+
+    assert_html '<p><div class="name">Joe</div><div class="name">Jack</div>shown</p>', source, :scope => hash, :sections => true
+  end
+
+  def test_inverted_section
+    source = %q{
+p
+ - person
+  .name = name
+ -! person
+  | No person
+ - !person
+  |  No person 2
+}
+
+    hash = {}
+
+    assert_html '<p>No person No person 2</p>', source, :scope => hash, :sections => true
+  end
+end

metadata

@@ -5,8 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
   - 0
   - 7
-  - 1
-  version: 0.7.1
+  - 2
+  version: 0.7.2
 platform: ruby
 authors: 
 - Andrew Stone
@@ -16,7 +16,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-11-03 00:00:00 -04:00
+date: 2010-11-09 00:00:00 -05:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -30,8 +30,8 @@ dependencies:
         segments: 
         - 0
         - 1
-        - 4
-        version: 0.1.4
+        - 5
+        version: 0.1.5
   type: :runtime
   version_requirements: *id001
 - !ruby/object:Gem::Dependency 
@@ -187,8 +187,10 @@ files:
 - lib/slim/end_inserter.rb
 - lib/slim/engine.rb
 - lib/slim/filter.rb
+- lib/slim/interpolation.rb
 - lib/slim/parser.rb
 - lib/slim/rails.rb
+- lib/slim/sections.rb
 - lib/slim/template.rb
 - lib/slim/version.rb
 - slim.gemspec
@@ -203,6 +205,7 @@ files:
 - test/slim/test_html_structure.rb
 - test/slim/test_parser_errors.rb
 - test/slim/test_ruby_errors.rb
+- test/slim/test_sections.rb
 - test/slim/test_slim_template.rb
 has_rdoc: true
 homepage: http://github.com/stonean/slim