slim 0.8.3 → 0.8.4

data/README.md

@@ -233,6 +233,10 @@ Here's a quick example to demonstrate what a Slim template looks like:
       h1 id="headline"
         == page_headline
 
+  Alternatively, if you prefer to use single equal sign, you may do so by setting the `auto_escape` option to false.
+
+    Slim::Engine.default_options[:auto_escape] = false
+
 ### Treat multiple lines of code as text that should bypass parsing
 
   Use a pipe (`|`) or single quote (`` ' ``) to start the escape.
@@ -332,5 +336,6 @@ This project is released under the MIT license.
 ## Slim related projects
 
 * [Textmate bundle](https://github.com/fredwu/ruby-slim-textmate-bundle)
+* [Haml2Slim converter](https://github.com/fredwu/haml2slim)
 * [Rails 3 Generators](https://github.com/leogalmeida/slim-rails)
 * [Slim for Clojure](https://github.com/chaslemley/slim.clj)

data/lib/slim/compiler.rb

@@ -2,7 +2,7 @@ module Slim
   # Compiles Slim expressions into Temple::HTML expressions.
   # @api private
   class Compiler < Filter
-    set_default_options :disable_capture => false
+    set_default_options :auto_escape => true
 
     # Handle control expression `[:slim, :control, code, content]`
     #
@@ -15,6 +15,14 @@ module Slim
         compile!(content)]
     end
 
+    # Handle comment expression `[:slim, :comment, content]`
+    #
+    # @param [Array] content Temple expression
+    # @return [Array] Compiled temple expression
+    def on_slim_comment(content)
+      [:html, :comment, compile!(content)]
+    end
+
     # Handle output expression `[:slim, :output, escape, code, content]`
     #
     # @param [Boolean] escape Escape html
@@ -23,7 +31,7 @@ module Slim
     # @return [Array] Compiled temple expression
     def on_slim_output(escape, code, content)
       if empty_exp?(content)
-        [:multi, escape ? [:escape, :dynamic, code] : [:dynamic, code], content]
+        [:multi, escape && options[:auto_escape] ? [:escape, :dynamic, code] : [:dynamic, code], content]
       else
         on_slim_output_block(escape, code, content)
       end
@@ -66,7 +74,7 @@ module Slim
     # @param [String] type Directive type
     # @return [Array] Compiled temple expression
     def on_slim_directive(type)
-      if type =~ /^doctype/
+      if type =~ /^doctype/i
         [:html, :doctype, $'.strip]
       end
     end

data/lib/slim/engine.rb

@@ -7,26 +7,46 @@ module Slim
     #     # Indent html for pretty debugging
     #     Slim::Engine.set_default_options :pretty => true
     #
+    # This overwrites some temple default options.
     set_default_options :pretty => false,
                         :attr_wrapper => '"',
                         :format => :html5,
                         :id_delimiter => nil,
-                        :generator => Temple::Generators::ArrayBuffer,
-                        :disable_capture => false,
-                        :debug => false
+                        :generator => Temple::Generators::ArrayBuffer
 
+    # Document all supported options with purpose, type etc.
+    #
+    # Type        | Name               | Default value                 | Purpose
+    # --------------------------------------------------------------------------------------------------------------------------------------------
+    # String      | :file              | nil                           | Name of parsed file, set automatically by Slim::Template
+    # Integer     | :tabsize           | 4                             | Number of whitespaces per tab (used by the parser)
+    # String list | :enable_engines    | All enabled                   | List of enabled embedded engines (whitelist)
+    # String list | :disable_engines   | None disabled                 | List of disabled embedded engines (blacklist)
+    # Boolean     | :sections          | false                         | Enable sections mode (logic-less)
+    # String      | :dictionary        | "self"                        | Name of dictionary variable in sections mode
+    # Symbol      | :dictionary_access | :wrapped                      | Access mode of dictionary variable (:wrapped, :symbol, :string)
+    # Boolean     | :disable_capture   | false (true in Rails)         | Disable capturing in blocks (blocks write to the default buffer then)
+    # Boolean     | :auto_escape       | true                          | Enable automatic escaping of strings
+    # Boolean     | :use_html_safe     | false (true in Rails)         | Use String#html_safe? from ActiveSupport (Works together with :auto_escape)
+    # Boolean     | :debug             | false                         | Enable debug outputs (Temple internals)
+    # Symbol      | :format            | :html5                        | HTML output format
+    # String      | :attr_wrapper      | '"'                           | Character to wrap attributes in html (can be ' or ")
+    # String      | :id_delimiter      | '_'                           | Joining character used if multiple html ids are supplied (e.g. #id1#id2)
+    # Boolean     | :pretty            | false                         | Pretty html indenting (This is slower!)
+    # Class       | :generator         | ArrayBuffer/RailsOutputBuffer | Temple code generator (defaults generates array buffer)
     use Slim::Parser, :file, :tabsize
     use Slim::EmbeddedEngine, :enable_engines, :disable_engines
     use Slim::Interpolation
     use Slim::Sections, :sections, :dictionary, :dictionary_access
     use Slim::EndInserter
-    use Slim::Compiler, :disable_capture
+    use Slim::Compiler, :disable_capture, :auto_escape
     filter :EscapeHTML, :use_html_safe
+    filter :Debugger, :debug, :debug_prefix => 'After Slim'
     use Temple::HTML::Pretty, :format, :attr_wrapper, :id_delimiter, :pretty
     filter :MultiFlattener
     filter :StaticMerger
     filter :DynamicInliner
-    filter :Debugger, :debug, :debug_prefix, :debug_pretty
+    filter :Debugger, :debug, :debug_prefix => 'Optimized code'
     chain << proc {|options| options[:generator].new }
   end
 end

data/lib/slim/filter.rb

@@ -9,6 +9,10 @@ module Slim
       [:slim, :control, code, compile!(content)]
     end
 
+    def on_slim_comment(content)
+      [:slim, :comment, compile!(content)]
+    end
+
     def on_slim_output(code, escape, content)
       [:slim, :output, code, escape, compile!(content)]
     end

data/lib/slim/parser.rb

@@ -69,7 +69,7 @@ module Slim
       #     Hello
       #     World!
       #
-      block_indent, in_slim_comment, in_html_comment, text_indent = nil, false, false, nil
+      block_indent, text_indent, in_comment = nil, nil, false
 
       str.each_line do |line|
         lineno += 1
@@ -107,7 +107,7 @@ module Slim
             # This line happens to be indented deeper (or equal) than the block start character (|, ', /).
             # This means that it's a part of the block.
 
-            if !in_slim_comment
+            if !in_comment
               # The indentation of first line of the text block determines the text base indentation.
               newline = text_indent ? "\n" : ''
               text_indent ||= indent
@@ -124,15 +124,10 @@ module Slim
             next
           end
 
-          # Closes the html comment
-          if in_html_comment
-            stacks.last << [:static, '-->']
-          end
-
           # It's guaranteed that we're now *not* in a block, because
           # the indent was less than the block start indent.
           block_indent = text_indent = nil
-          in_slim_comment = in_html_comment = false
+          in_comment = false
         end
 
         # If there's more stacks than indents, it means that the previous
@@ -170,24 +165,26 @@ module Slim
         case line[0]
         when ?|, ?', ?/
           # Found a block.
+          ch = line.slice!(0)
 
           # We're now expecting the next line to be indented, so we'll need
           # to push a block to the stack.
           block = [:multi]
-          stacks.last << (line[0] == ?' ? [:multi, block, [:slim, :text, ' ']] : block)
+          stacks.last << if ch == ?'
+                           # Additional whitespace in front
+                           [:multi, block, [:slim, :text, ' ']]
+                         elsif ch == ?/ && line[0] == ?!
+                           # HTML comment
+                           line.slice!(0)
+                           [:slim, :comment, block]
+                         else
+                           in_comment = ch == ?/
+                           block
+                         end
           stacks << block
           block_indent = indent
 
-          in_slim_comment = line[0] == ?/ && line[1] != ?!
-          in_html_comment = line[0] == ?/ && line[1] == ?! && line.slice!(0)
-          line.slice!(0)
-
-          # We're entering a block of html comments, so let's add an opening tag
-          if in_html_comment
-            block << [:static, '<!--']
-          end
-
-          if !in_slim_comment && !line.strip.empty?
+          if !in_comment && !line.strip.empty?
             block << [:slim, :text, line.sub(/^( )/, '')]
             text_indent = block_indent + ($1 ? 2 : 1)
           end

data/lib/slim/sections.rb

@@ -17,6 +17,8 @@ module Slim
     def compile(exp)
       if options[:sections]
         # Store the dictionary in the _slimdict variable
+        dictionary = options[:dictionary]
+        dictionary = "Slim::Wrapper.new(#{dictionary})" if options[:dictionary_access] == :wrapped
         [:multi,
          [:block, "_slimdict = #{dictionary}"],
          super]
@@ -52,6 +54,7 @@ module Slim
        [:block,   "if #{tmp1} == true"],
                      content,
        [:block,   'else'],
+                    # Wrap map in array because maps implement each
        [:block,     "#{tmp1} = [#{tmp1}] if #{tmp1}.respond_to?(:has_key?) || !#{tmp1}.respond_to?(:map)"],
        [:block,     "#{tmp2} = _slimdict"],
        [:block,     "#{tmp1}.each do |_slimdict|"],
@@ -67,7 +70,10 @@ module Slim
       [:slim, :output, escape, access(name), content]
     end
 
+    private
+
     def access(name)
+      return name if name == 'yield'
       case options[:dictionary_access]
       when :string
         "_slimdict[#{name.to_s.inspect}]"
@@ -75,14 +81,5 @@ module Slim
         "_slimdict[#{name.to_sym.inspect}]"
       end
     end
-
-    def dictionary
-      if options[:dictionary_access] == :wrapped
-        "Slim::Wrapper.new(#{options[:dictionary]})"
-      else
-        options[:dictionary]
-      end
-    end
-
   end
 end

data/lib/slim/version.rb

@@ -1,3 +1,3 @@
 module Slim
-  VERSION = '0.8.3'
+  VERSION = '0.8.4'
 end

data/lib/slim/wrapper.rb

@@ -1,9 +1,5 @@
 module Slim
   # For logic-less mode, objects can be encased in the Wrapper class.
-  #
-  # For Rails, this allows us to use the environment provided for rendering
-  # a view including the instance variables, view helper and application helper
-  # methods.
   class Wrapper
     attr_reader :value, :parent
 
@@ -24,15 +20,13 @@ module Slim
     # go through the same steps on the parent object.  This is useful when
     # you are iterating over objects.
     def [](name)
-      if value.respond_to?(name)
-        wrap value.send(name)
-      elsif value.respond_to?(:has_key?) && value.has_key?(name.to_sym)
-        wrap value[name]
-      elsif value.instance_variable_defined?("@#{name}")
-        wrap value.instance_variable_get("@#{name}")
-      elsif parent
-        parent[name]
+      return wrap(value.send(name)) if value.respond_to?(name)
+      if value.respond_to?(:has_key?)
+        return wrap(value[name.to_sym]) if value.has_key?(name.to_sym)
+        return wrap(value[name.to_s]) if value.has_key?(name.to_s)
       end
+      return wrap(value.instance_variable_get("@#{name}")) if value.instance_variable_defined?("@#{name}")
+      parent[name] if parent
     end
 
     # Empty objects must appear empty for inverted sections

metadata

@@ -5,8 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
   - 0
   - 8
-  - 3
-  version: 0.8.3
+  - 4
+  version: 0.8.4
 platform: ruby
 authors: 
 - Andrew Stone
@@ -16,7 +16,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-12-23 00:00:00 +11:00
+date: 2011-01-26 00:00:00 -05:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -30,8 +30,8 @@ dependencies:
         segments: 
         - 0
         - 1
-        - 6
-        version: 0.1.6
+        - 7
+        version: 0.1.7
   type: :runtime
   version_requirements: *id001
 - !ruby/object:Gem::Dependency 
@@ -44,8 +44,8 @@ dependencies:
       - !ruby/object:Gem::Version 
         segments: 
         - 1
-        - 1
-        version: "1.1"
+        - 2
+        version: "1.2"
   type: :runtime
   version_requirements: *id002
 - !ruby/object:Gem::Dependency