slim 0.6.1 → 0.7.0.beta.2

data/lib/slim/end_inserter.rb

@@ -0,0 +1,57 @@
+module Slim
+  # In Slim you don't need to close any blocks:
+  #
+  #   - if Slim.awesome?
+  #     | But of course it is!
+  #
+  # However, the parser is not smart enough (and that's a good thing) to
+  # automatically insert end's where they are needed. Luckily, this filter
+  # does *exactly* that (and it does it well!)
+  class EndInserter < Filter
+    ELSE_REGEX = /^(else|elsif|when|end)\b/
+    END_REGEX = /^end\b/
+
+    def on_multi(*exps)
+      result = [:multi]
+      # This variable is true if the previous line was
+      # (1) a control code and (2) contained indented content.
+      prev_indent = false
+
+      exps.each do |exp|
+        if control?(exp)
+          if prev_indent
+            # Two control code in a row. If this one is *not*
+            # an else block, we should close the previous one.
+            append_end(result) if exp[2] !~ ELSE_REGEX
+            prev_indent = exp[2].match(END_REGEX).nil?
+          else
+            # Indent if the control code contains something.
+            prev_indent = !empty_exp?(exp[3])
+          end
+        elsif exp[0] != :newline && prev_indent
+          # This is *not* a control code, so we should close the previous one.
+          # Ignores newlines because they will be inserted after each line.
+          append_end(result)
+          prev_indent = false
+        end
+
+        result << compile(exp)
+      end
+
+      # The last line can be a control code too.
+      prev_indent ? append_end(result) : result
+    end
+
+    private
+
+    # Appends an end.
+    def append_end(result)
+      result << [:block, 'end']
+    end
+
+    # Checks if an expression is a Slim control code.
+    def control?(exp)
+      exp[0] == :slim && exp[1] == :control
+    end
+  end
+end

data/lib/slim/engine.rb

@@ -1,19 +1,21 @@
 module Slim
-  class Engine
-    include Compiler
+  class Engine < Temple::Engine
+    use Slim::Parser
+    use Slim::EndInserter
+    use Slim::Compiler, :use_html_safe
+    #use Slim::Debugger
+    use Temple::HTML::Fast, :format, :attr_wrapper => '"', :format => :html5
+    filter :MultiFlattener
+    filter :StaticMerger
+    filter :DynamicInliner
+    generator :ArrayBuffer
 
-    attr_reader :compiled
-    attr_reader :optimized
-
-    # @param template The .slim template to convert
-    # @return [Slim::Engine] instance of engine
-    def initialize(template)
-      @template = template
-      compile
-    end
-
-    def render(scope = Object.new, locals = {})
-      scope.instance_eval(optimized)
+    def self.new(*args)
+      if args.first.respond_to?(:each_line)
+        Template.new(Hash === args.last ? args.last : {}) { args.first }
+      else
+        super
+      end
     end
   end
 end

data/lib/slim/filter.rb

@@ -0,0 +1,44 @@
+module Slim
+  class Filter
+    include Temple::Utils
+
+    DEFAULT_OPTIONS = {}
+
+    def initialize(options = {})
+      @options = DEFAULT_OPTIONS.merge(options)
+    end
+
+    def compile(exp)
+      if exp[0] == :slim
+        _, type, *args = exp
+      else
+        type, *args = exp
+      end
+
+      if respond_to?("on_#{type}")
+        send("on_#{type}", *args)
+      else
+        exp
+      end
+    end
+
+    def on_control(code, content)
+      [:slim, :control, code, compile(content)]
+    end
+
+    def on_tag(name, attrs, content)
+      [:slim, :tag, name, attrs, compile(content)]
+    end
+
+    def on_multi(*exps)
+      [:multi, *exps.map { |exp| compile(exp) }]
+    end
+  end
+
+  class Debugger < Filter
+    def compile(exp)
+      puts exp.inspect
+      exp
+    end
+  end
+end

data/lib/slim/helpers.rb

@@ -0,0 +1,37 @@
+module Slim
+  module Helpers
+    def list_of(enum, &block)
+      enum.map do |i|
+        "<li>#{yield(i)}</li>"
+      end.join("\n")
+    end
+
+    def escape_html_safe(html)
+      html.html_safe? ? html : escape_html(html)
+    end
+
+    if defined?(EscapeUtils)
+      def escape_html(html)
+        EscapeUtils.escape_html(html.to_s)
+      end
+    elsif RUBY_VERSION > '1.9'
+      ESCAPE_HTML = {
+        '&' => '&amp;',
+        '"' => '&quot;',
+        '<' => '&lt;',
+        '>' => '&gt;',
+        '/' => '&#47;',
+      }
+
+      def escape_html(html)
+        html.to_s.gsub(/[&\"<>\/]/, ESCAPE_HTML)
+      end
+    else
+      def escape_html(html)
+        html.to_s.gsub(/&/n, '&amp;').gsub(/\"/n, '&quot;').gsub(/>/n, '&gt;').gsub(/</n, '&lt;').gsub(/\//, '&#47;')
+      end
+    end
+
+    module_function :escape_html, :escape_html_safe
+  end
+end

data/lib/slim/parser.rb

@@ -0,0 +1,355 @@
+module Slim
+  class Parser
+    class SyntaxError < StandardError
+      def initialize(message, line, lineno, column = 0)
+        @message = message
+        @line = line.strip
+        @lineno = lineno
+        @column = column
+      end
+
+      def to_s
+        %{#{@message}
+  Line #{@lineno}
+    #{@line}
+    #{' ' * @column}^
+        }
+      end
+    end
+
+    attr_reader :options
+
+    def initialize(options = {})
+      @options = options
+      @tab     = ' ' * (options[:tabsize] || 4)
+    end
+
+    def compile(str)
+      lineno = 0
+      result = [:multi]
+
+      # Since you can indent however you like in Slim, we need to keep a list
+      # of how deeply indented you are. For instance, in a template like this:
+      #
+      #   ! doctype     # 0 spaces
+      #   html          # 0 spaces
+      #    head         # 1 space
+      #       title     # 4 spaces
+      #
+      # indents will then contain [0, 1, 4] (when it's processing the last line.)
+      #
+      # We uses this information to figure out how many steps we must "jump"
+      # out when we see an de-indented line.
+      indents = [0]
+
+      # Whenever we want to output something, we'll *always* output it to the
+      # last stack in this array. So when there's a line that expects
+      # indentation, we simply push a new stack onto this array. When it
+      # processes the next line, the content will then be outputted into that
+      # stack.
+      stacks = [result]
+
+      # String buffer used for broken line (Lines ending with \)
+      broken_line = nil
+
+      # We have special treatment for text blocks:
+      #
+      #   |
+      #     Hello
+      #     World!
+      #
+      text_indent, text_base_indent = nil, nil
+
+      str.each_line do |line|
+        lineno += 1
+
+        # Remove the newline at the ned
+        line.chop!
+
+        # Handle broken lines
+        if broken_line
+          if broken_line[-1] == ?\\
+            broken_line << "\n#{line}"
+            next
+          end
+          broken_line = nil
+        end
+
+        # Figure out the indentation. Kinda ugly/slow way to support tabs,
+        # but remember that this is only done at parsing time.
+        indent = line[/^[ \t]*/].gsub("\t", @tab).size
+
+        # Remove the indentation
+        line.lstrip!
+
+        if line.strip.empty? || line[0] == ?/
+          # This happens to be an empty line or a comment, so we'll just have to make sure
+          # the generated code includes a newline (so the line numbers in the
+          # stack trace for an exception matches the ones in the template).
+          stacks.last << [:newline]
+          next
+        end
+
+        # Handle text blocks with multiple lines
+        if text_indent
+          if indent > text_indent
+            # This line happens to be indented deeper (or equal) than the block start character (|, ', `).
+            # This means that it's a part of the text block.
+
+            # The indentation of first line of the text block determines the text base indentation.
+            text_base_indent ||= indent
+
+            # The text block lines must be at least indented as deep as the first line.
+            offset = indent - text_base_indent
+            syntax_error! 'Unexpected text indentation', line, lineno if offset < 0
+
+            # Generate the additional spaces in front.
+            i = ' ' * offset
+            stacks.last << [:slim, :text, i + line]
+            stacks.last << [:newline]
+
+            # Mark this line as it's been indented as the text block start character.
+            indent = text_indent
+
+            next
+          end
+
+          # It's guaranteed that we're now *not* in a text block, because
+          # the indent will always be set to the text block start indent.
+          text_indent = text_base_indent = nil
+        end
+
+        # If there's more stacks than indents, it means that the previous
+        # line is expecting this line to be indented.
+        expecting_indentation = stacks.size > indents.size
+
+        if indent > indents.last
+          # This line was actually indented, so we'll have to check if it was
+          # supposed to be indented or not.
+          syntax_error! 'Unexpected indentation', line, lineno unless expecting_indentation
+
+          indents << indent
+        else
+          # This line was *not* indented more than the line before,
+          # so we'll just forget about the stack that the previous line pushed.
+          stacks.pop if expecting_indentation
+
+          # This line was deindented.
+          # Now we're have to go through the all the indents and figure out
+          # how many levels we've deindented.
+          while indent < indents.last
+            indents.pop
+            stacks.pop
+          end
+
+          # This line's indentation happens lie "between" two other line's
+          # indentation:
+          #
+          #   hello
+          #       world
+          #     this      # <- This should not be possible!
+          syntax_error! 'Malformed indentation', line, lineno if indents.last < indent
+        end
+
+        case line[0]
+        when ?|, ?', ?`
+          # Found a piece of text.
+
+          # 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 << block
+          stacks << block
+          text_indent = indent
+
+          line.slice!(0)
+          if !line.strip.empty?
+            block << [:slim, :text, line.sub(/^( )/, '')]
+            text_base_indent = text_indent + ($1 ? 2 : 1)
+          end
+        when ?-, ?=
+          # Found a potential code block.
+
+          # First of all we need to push a exp into the stack. Anything
+          # indented deeper will be pushed into this exp. We'll include the
+          # same exp in the current-stack, which makes sure that it'll be
+          # included in the generated code.
+          block = [:multi]
+          if line[1] == ?=
+            broken_line = line[2..-1].strip
+            stacks.last << [:slim, :output, false, broken_line, block]
+          elsif line[0] == ?=
+            broken_line = line[1..-1].strip
+            stacks.last << [:slim, :output, true, broken_line, block]
+          else
+            broken_line = line[1..-1].strip
+            stacks.last << [:slim, :control, broken_line, block]
+          end
+          stacks << block
+        when ?!
+          # Found a directive (currently only used for doctypes)
+          stacks.last << [:slim, :directive, line[1..-1].strip]
+        else
+          if line =~ /^(\w+):\s*$/
+            # Embedded template detected. It is treated like a text block.
+            block = [:slim, :embedded, $1]
+            stacks.last << block
+            stacks << block
+            text_indent = indent
+          else
+            # Found a HTML tag.
+            exp, content, broken_line = parse_tag(line, lineno)
+            stacks.last << exp
+            stacks << content if content
+          end
+        end
+      end
+
+      result
+    end
+
+    private
+
+    ATTR_REGEX = /^ ([\w-]+)=/
+    QUOTED_VALUE_REGEX = /^("[^"]+"|'[^']+')/
+    ATTR_SHORTHAND = {
+      '#' => 'id',
+      '.' => 'class',
+    }
+    DELIMITERS = {
+      '(' => ')',
+      '[' => ']',
+      '{' => '}',
+    }
+    DELIMITER_REGEX = /^([\(\[\{])/
+    CLOSE_DELIMITER_REGEX = /^([\)\]\}])/
+    if RUBY_VERSION > '1.9'
+      CLASS_ID_REGEX = /^(#|\.)([\w\u00c0-\uFFFF][\w:\u00c0-\uFFFF-]*)/
+    else
+      CLASS_ID_REGEX = /^(#|\.)([\w][\w:-]*)/
+    end
+
+    def parse_tag(line, lineno)
+      orig_line = line
+
+      if line =~ /^(#|\.)/
+        tag = 'div'
+      elsif line =~ /^[\w:]+/
+        tag = $&
+        line = $'
+      else
+        syntax_error! 'Unknown line indicator', orig_line, lineno
+      end
+
+      # 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 = []
+
+      # Find any literal class/id attributes
+      while line =~ CLASS_ID_REGEX
+        attributes << [ATTR_SHORTHAND[$1], $2]
+        line = $'
+      end
+
+      # Check to see if there is a delimiter right after the tag name
+      delimiter = ''
+      if line =~ DELIMITER_REGEX
+        delimiter = DELIMITERS[$1]
+        # Replace the delimiter with a space so we can continue parsing as normal.
+        line[0] = ?\s
+      end
+
+      # Parse attributes
+      while line =~ ATTR_REGEX
+        key = $1
+        line = $'
+        if line =~ QUOTED_VALUE_REGEX
+          # Value is quote (static)
+          line = $'
+          value = $1[1..-2]
+        else
+          # Value is ruby code
+          line, value = parse_ruby_attribute(orig_line, line, lineno, delimiter)
+        end
+        attributes << [key, value]
+      end
+
+      # Find ending delimiter
+      if !delimiter.empty?
+        if line[0, 1] == delimiter
+          line.slice!(0)
+        else
+          syntax_error! "Expected closing attribute delimiter #{delimiter}", orig_line, lineno, orig_line.size - line.size
+        end
+      end
+
+      content = [:multi]
+      broken_line = nil
+
+      if line.strip.empty?
+        # If the line was empty there might be some indented content in the
+        # lines beneath it. We'll handle this by making this method return
+        # the block-variable. #compile will then push this onto the
+        # stacks-array.
+        block = content
+      elsif line =~ /^\s*=(=?)/
+        # Output
+        block = [:multi]
+        broken_line = $'.strip
+        content << [:slim, :output, $1 != '=', broken_line, block]
+      else
+        # Text content
+        line.sub!(/^ /, '')
+        content << [:slim, :text, line]
+      end
+
+      return [:slim, :tag, tag, attributes, content], block, broken_line
+    end
+
+    def parse_ruby_attribute(orig_line, line, lineno, delimiter)
+      # Delimiter stack
+      stack = []
+
+      # Attribute value buffer
+      value = ''
+
+      # Attribute ends with space or attribute delimiter
+      end_regex = /^[\s#{Regexp.escape delimiter}]/
+
+      until line.empty?
+        if stack.empty? && line =~ end_regex
+          # Stack is empty, this means we left the attribute value
+          # if next character is space or attribute delimiter
+          break
+        elsif line =~ DELIMITER_REGEX
+          # Delimiter found, push it on the stack
+          stack << DELIMITERS[$1]
+          value << line.slice!(0)
+        elsif line =~ CLOSE_DELIMITER_REGEX
+          # Closing delimiter found, pop it from the stack if everything is ok
+          syntax_error! "Unexpected closing #{$1}", orig_line, lineno if stack.empty?
+          syntax_error! "Expected closing #{stack.last}", orig_line, lineno if stack.last != $1
+          value << line.slice!(0)
+          stack.pop
+        else
+          value << line.slice!(0)
+        end
+      end
+
+      syntax_error! "Expected closing attribute delimiter #{stack.last}", orig_line, lineno if !stack.empty?
+      syntax_error! 'Invalid empty attribute', orig_line, lineno if value.empty?
+
+      # Remove attribute wrapper which doesn't belong to the ruby code
+      # e.g id=[hash[:a] + hash[:b]]
+      value = value[1..-2] if value =~ DELIMITER_REGEX && DELIMITERS[value[0, 1]] == value[-1, 1]
+
+      [line, '#{%s}' % value]
+    end
+
+    # A little helper for raising exceptions.
+    def syntax_error!(*args)
+      raise SyntaxError.new(*args)
+    end
+  end
+end