slim 1.2.2 → 1.3.0

data/lib/slim/engine.rb

@@ -2,12 +2,9 @@ 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
-    #
-    # This overwrites some temple default options.
+    # This overwrites some Temple default options or sets default options for Slim specific filters.
+    # It is recommended to set the default settings only once in the code and avoid duplication. Only use
+    # `set_default_options` when you have to override some default settings.
     set_default_options :pretty => false,
                         :sort_attrs => true,
                         :attr_wrapper => '"',
@@ -15,54 +12,10 @@ module Slim
                         :remove_empty_attrs => true,
                         :generator => Temple::Generators::ArrayBuffer,
                         :default_tag => 'div'
-    #
-    # 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      | :encoding          | "utf-8"                       | Set encoding of template
-    # String      | :default_tag       | "div"                         | Default tag to be used if tag name is omitted
-    # Hash        | :shortcut          | {'.' => 'class', ...}         | Attribute shortcuts
-    # 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 
-    # Boolean     | :disable_escape    | false                         | Disable automatic escaping of strings
-    # Boolean     | :use_html_safe     | false (true in Rails)         | Use String#html_safe? from ActiveSupport (Works together with :disable_escape)
-    # Symbol      | :format            | :xhtml                        | HTML output format
-    # String      | :attr_wrapper      | '"'                           | Character to wrap attributes in html (can be ' or ")
-    # Hash        | :attr_delimiter    | {'class' => ' '}              | Joining character used if multiple html attributes are supplied (e.g. id1_id2)
-    # Boolean     | :sort_attrs        | true                          | Sort attributes by name
-    # Boolean     | :remove_empty_attrs| true                          | Remove attributes with empty value
-    # Boolean     | :pretty            | false                         | Pretty html indenting (This is slower!)
-    # String      | :indent            | '  '                          | Indentation string
-    # Boolean     | :streaming         | false (true in Rails > 3.1)   | Enable output streaming
-    # Class       | :generator         | ArrayBuffer/RailsOutputBuffer | Temple code generator (default generator generates array buffer)
-    #
-    # It is also possible to set all options supported by the generator (option :generator). The standard generators
-    # support the options :buffer and :capture_generator.
-    #
-    # Options can be set at multiple positions. Slim/Temple uses a inheritance mechanism to allow
-    # subclasses to overwrite options of the superclass. The option priorities are as follows:
-    #
-    # Custom (Options passed by the user) > Slim::Template > Slim::Engine > Parser/Filter/Generator (e.g Slim::Parser, Slim::Compiler)
-    #
-    # It is also possible to set options for superclasses like Temple::Engine. But this will affect all temple template engines then.
-    #
-    # Slim::Engine > Temple::Engine
-    # Slim::Compiler > Temple::Filter
-    #
-    # It is recommended to set the default settings only once in the code and avoid duplication. Only use
-    # `set_default_options` when you have to override some default settings.
-    #
+
     use Slim::Parser, :file, :tabsize, :encoding, :shortcut, :default_tag
     use Slim::EmbeddedEngine, :enable_engines, :disable_engines, :pretty
     use Slim::Interpolation
-    use Slim::Sections, :sections, :dictionary, :dictionary_access
     use Slim::EndInserter
     use Slim::Compiler, :disable_capture, :attr_delimiter, :attr_wrapper, :sort_attrs, :remove_empty_attrs, :default_tag
     html :AttributeMerger, :attr_delimiter

data/lib/slim/filter.rb

@@ -7,6 +7,11 @@ module Slim
   #
   # @api private
   class Filter < Temple::HTML::Filter
+    # Pass-through handler
+    def on_slim_text(content)
+      [:slim, :text, compile(content)]
+    end
+
     # Pass-through handler
     def on_slim_embedded(type, content)
       [:slim, :embedded, code, compile(content)]
@@ -17,11 +22,6 @@ module Slim
       [:slim, :control, code, compile(content)]
     end
 
-    # Pass-through handler
-    def on_slim_condcomment(condition, content)
-      [:slim, :condcomment, condition, compile(content)]
-    end
-
     # Pass-through handler
     def on_slim_output(code, escape, content)
       [:slim, :output, code, escape, compile(content)]

data/lib/slim/grammar.rb

@@ -6,10 +6,10 @@ module Slim
 
     Expression <<
       [:slim, :control, String, Expression]           |
-      [:slim, :condcomment, String, Expression]       |
       [:slim, :output, Bool, String, Expression]      |
       [:slim, :interpolate, String]                   |
       [:slim, :embedded, String, Expression]          |
+      [:slim, :text, Expression]                      |
       [:slim, :tag, String, SlimAttrs, 'Expression?']
 
     SlimAttrs <<

data/lib/slim/interpolation.rb

@@ -16,9 +16,7 @@ module Slim
         case string
         when /\A\\#\{/
           # Escaped interpolation
-          # Use [:slim, :output] because this is used by InterpolateTiltEngine
-          # to filter out protected strings (Issue #141).
-          block << [:slim, :output, false, '\'#{\'', [:multi]]
+          block << [:static, '#{']
           string = $'
         when /\A#\{/
           # Interpolation

data/lib/slim/logic_less.rb

@@ -0,0 +1,6 @@
+require 'slim'
+require 'slim/logic_less/filter'
+require 'slim/logic_less/wrapper'
+
+# Insert plugin filter into Slim engine chain
+Slim::Engine.after(Slim::Interpolation, Slim::LogicLess, :logic_less, :dictionary, :dictionary_access)

data/lib/slim/{sections.rb → logic_less/filter.rb}

@@ -1,10 +1,10 @@
 module Slim
   # Handle logic-less mode
-  # This filter can be activated with the option "sections"
+  # This filter can be activated with the option "logic_less"
   # @api private
-  class Sections < Filter
-    set_default_options :dictionary => 'self',
-                        :sections => false,
+  class LogicLess < Filter
+    set_default_options :logic_less => true,
+                        :dictionary => 'self',
                         :dictionary_access => :wrapped # :symbol, :string, :wrapped
 
     def initialize(opts = {})
@@ -15,12 +15,12 @@ module Slim
     end
 
     def call(exp)
-      if options[:sections]
-        # Store the dictionary in the _slimdict variable
+      if options[:logic_less]
+        @dict = unique_name
         dictionary = options[:dictionary]
-        dictionary = "Slim::Wrapper.new(#{dictionary})" if options[:dictionary_access] == :wrapped
+        dictionary = "::Slim::LogicLess::Wrapper.new(#{dictionary})" if options[:dictionary_access] == :wrapped
         [:multi,
-         [:code, "_slimdict = #{dictionary}"],
+         [:code, "#{@dict} = #{dictionary}"],
          super]
       else
         exp
@@ -37,7 +37,7 @@ module Slim
     end
 
     def on_slim_output(escape, name, content)
-      raise 'Output statements with content are forbidden in sections mode' if !empty_exp?(content)
+      raise 'Output statements with content are forbidden in logic less mode' if !empty_exp?(content)
       [:slim, :output, escape, access(name), content]
     end
 
@@ -50,11 +50,11 @@ module Slim
     end
 
     def on_dynamic(code)
-      raise 'Embedded code is forbidden in sections mode'
+      raise 'Embedded code is forbidden in logic less mode'
     end
 
     def on_code(code)
-      raise 'Embedded code is forbidden in sections mode'
+      raise 'Embedded code is forbidden in logic less mode'
     end
 
     protected
@@ -77,9 +77,9 @@ module Slim
         [:multi,
          # Wrap map in array because maps implement each
          [:code, "#{tmp1} = [#{tmp1}] if #{tmp1}.respond_to?(:has_key?) || !#{tmp1}.respond_to?(:map)"],
-         [:code, "#{tmp2} = _slimdict"],
-         [:block, "#{tmp1}.each do |_slimdict|", content],
-         [:code, "_slimdict = #{tmp2}"]]]]
+         [:code, "#{tmp2} = #{@dict}"],
+         [:block, "#{tmp1}.each do |#{@dict}|", content],
+         [:code, "#{@dict} = #{tmp2}"]]]]
     end
 
     private
@@ -88,9 +88,9 @@ module Slim
       return name if name == 'yield'
       case options[:dictionary_access]
       when :string
-        "_slimdict[#{name.to_s.inspect}]"
+        "#{@dict}[#{name.to_s.inspect}]"
       else
-        "_slimdict[#{name.to_sym.inspect}]"
+        "#{@dict}[#{name.to_sym.inspect}]"
       end
     end
   end

data/lib/slim/logic_less/wrapper.rb

@@ -0,0 +1,64 @@
+module Slim
+  class LogicLess
+    # For logic-less mode, objects can be encased in the Wrapper class.
+    # @api private
+    class Wrapper
+      attr_reader :value, :parent
+
+      def initialize(value, parent = nil)
+        @value, @parent = value, parent
+      end
+
+      # To find the reference, first check for standard method
+      # access by using respond_to?.
+      #
+      # If not found, check to see if the value is a hash and if the
+      # the name is a key on the hash.
+      #
+      # Not a hash, or not a key on the hash, then check to see if there
+      # is an instance variable with the name.
+      #
+      # If the instance variable doesn't exist and there is a parent object,
+      # go through the same steps on the parent object.  This is useful when
+      # you are iterating over objects.
+      def [](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
+        begin
+          var_name = "@#{name}"
+          return wrap(value.instance_variable_get(var_name)) if value.instance_variable_defined?(var_name)
+        rescue NameError
+          # Do nothing
+        end
+        parent[name] if parent
+      end
+
+      # Empty objects must appear empty for inverted sections
+      def empty?
+        value.respond_to?(:empty) && value.empty?
+      end
+
+      # Used for output
+      def to_s
+        value.to_s
+      end
+
+      private
+
+      def wrap(response)
+        # Primitives are not wrapped
+        if [String, Numeric, TrueClass, FalseClass, NilClass].any? {|primitive| primitive === response }
+          response
+          # Enumerables are mapped with wrapped values (except Hash-like objects)
+        elsif !response.respond_to?(:has_key?) && response.respond_to?(:map)
+          response.map {|v| wrap(v) }
+        else
+          Wrapper.new(response, self)
+        end
+      end
+    end
+  end
+end

data/lib/slim/parser.rb

@@ -64,7 +64,7 @@ module Slim
       end
 
       result = [:multi]
-      reset(str.split($/), [result])
+      reset(str.split(/\r?\n/), [result])
 
       parse_line while next_line
 
@@ -180,11 +180,11 @@ module Slim
         # Found a comment block.
         if @line =~ %r{\A/!( ?)(.*)\Z}
           # HTML comment
-          @stacks.last << [:html, :comment, parse_text_block($2, @indents.last + $1.size + 2)]
+          @stacks.last << [:html, :comment, [:slim, :text, parse_text_block($2, @indents.last + $1.size + 2)]]
         elsif @line =~ %r{\A/\[\s*(.*?)\s*\]\s*\Z}
           # HTML conditional comment
           block = [:multi]
-          @stacks.last << [:slim, :condcomment, $1, block]
+          @stacks.last << [:html, :condcomment, $1, block]
           @stacks << block
         else
           # Slim comment
@@ -193,13 +193,13 @@ module Slim
       when /\A([\|'])( ?)(.*)\Z/
         # Found a text block.
         trailing_ws = $1 == "'"
-        @stacks.last << parse_text_block($3, @indents.last + $2.size + 1)
+        @stacks.last << [:slim, :text, parse_text_block($3, @indents.last + $2.size + 1)]
         @stacks.last << [:static, ' '] if trailing_ws
       when /\A-/
         # Found a code block.
         # We expect the line to be broken or the next line to be indented.
-        block = [:multi]
         @line.slice!(0)
+        block = [:multi]
         @stacks.last << [:slim, :control, parse_broken_line, block]
         @stacks << block
       when /\A=/
@@ -306,10 +306,9 @@ module Slim
         @stacks.delete_at(i)
       when /\A\s*=(=?)('?)/
         # Handle output code
-        block = [:multi]
         @line = $'
-        content = [:slim, :output, $1 != '=', parse_broken_line, block]
-        tag << content
+        block = [:multi]
+        tag << [:slim, :output, $1 != '=', parse_broken_line, block]
         @stacks.last << [:static, ' '] unless $2.empty?
         @stacks << block
       when /\A\s*\//
@@ -321,17 +320,16 @@ module Slim
         @stacks << content
       when /\A( ?)(.*)\Z/
         # Text content
-        tag << parse_text_block($2, @orig_line.size - @line.size + $1.size, true)
+        tag << [:slim, :text, parse_text_block($2, @orig_line.size - @line.size + $1.size, true)]
       end
     end
 
     def parse_attributes
       attributes = [:slim, :attrs]
-      attribute = nil
 
       # Find any shortcut attributes
       while @line =~ @shortcut_regex
-        # The class/id attribute is :static instead of :slim :text,
+        # The class/id attribute is :static instead of :slim :interpolate,
         # because we don't want text interpolation in .class or #id shortcut
         attributes << [:html, :attr, @shortcut[$1][1], [:static, $2]]
         @line = $'

data/lib/slim/translator.rb

@@ -0,0 +1,117 @@
+require 'slim'
+
+module Slim
+  class Translator < Filter
+    set_default_options :tr_mode => :dynamic,
+                        :tr_fn   => '_'
+
+    if Object.const_defined?(:I18n)
+      set_default_options :tr_fn => '::Slim::Translator.i18n_text',
+                          :tr => true
+    elsif Object.const_defined?(:GetText)
+      set_default_options :tr_fn => '::GetText._',
+                          :tr => true
+    elsif Object.const_defined?(:FastGettext)
+      set_default_options :tr_fn => '::FastGettext::Translation._',
+                          :tr => true
+    end
+
+    def self.i18n_text(text)
+      I18n.t!(text)
+    rescue I18n::MissingTranslationData
+      text
+    end
+
+    def self.i18n_key(text)
+      key = text.parameterize.underscore
+      I18n.t!(key)
+    rescue I18n::MissingTranslationData
+      text
+    end
+
+    def call(exp)
+      if options[:tr]
+        super
+      else
+        exp
+      end
+    end
+
+    def initialize(opts)
+      super
+      case options[:tr_mode]
+      when :static
+        @translator = StaticTranslator.new(options)
+      when :dynamic
+        @translator = DynamicTranslator.new(options)
+      else
+        raise "Invalid translator mode #{options[:tr_mode].inspect}"
+      end
+    end
+
+    def on_slim_text(exp)
+      [:slim, :text, @translator.call(exp)]
+    end
+
+    private
+
+    class StaticTranslator < Filter
+      def initialize(opts)
+        super
+        @translate = eval("proc {|string| #{options[:tr_fn]}(string) }")
+      end
+
+      def call(exp)
+        @text, @captures = '', []
+        result = compile(exp)
+
+        text = @translate.call(@text)
+        while text =~ /%(\d+)/
+          result << [:static, $`] << @captures[$1.to_i - 1]
+          text = $'
+        end
+        result << [:static, text]
+      end
+
+      def on_static(text)
+        @text << text
+        [:multi]
+      end
+
+      def on_slim_output(escape, code, content)
+        @captures << [:slim, :output, escape, code, content]
+        @text << "%#{@captures.size}"
+        [:multi]
+      end
+    end
+
+    class DynamicTranslator < Filter
+      def call(exp)
+        @captures_count, @captures_var, @text = 0, unique_name, ''
+
+        result = compile(exp)
+
+        if @captures_count > 0
+          result.insert(1, [:code, "#{@captures_var}=[]"])
+          result << [:slim, :output, false, "#{options[:tr_fn]}(#{@text.inspect}).gsub(/%(\\d+)/) { #{@captures_var}[$1.to_i-1] }", [:multi]]
+        else
+          result << [:slim, :output, false, "#{options[:tr_fn]}(#{@text.inspect})", [:multi]]
+        end
+      end
+
+      def on_static(text)
+        @text << text
+        [:multi]
+      end
+
+      def on_slim_output(escape, code, content)
+        @captures_count += 1
+        @text << "%#{@captures_count}"
+        [:capture, "#{@captures_var}[#{@captures_count-1}]", [:slim, :output, escape, code, content]]
+      end
+    end
+  end
+end
+
+# Insert plugin filter into Slim engine chain
+Slim::Engine.before(Slim::EndInserter, Slim::Translator, :tr, :tr_fn, :tr_mode)