haml-edge 2.1.44 → 2.1.45

data/EDGE_GEM_VERSION

@@ -1 +1 @@
-2.1.44
+2.1.45

data/README.md

@@ -57,11 +57,15 @@ check out the [YARD documentation](http://haml-lang.com/docs/yardoc).
 ### Haml
 
 The most basic element of Haml
-is a shorthand for creating HTML
+is a shorthand for creating HTML:
 
     %tagname{:attr1 => 'value1', :attr2 => 'value2'} Contents
 
 No end-tag is needed; Haml handles that automatically.
+If you prefer HTML-style attributes, you can also use:
+
+    %tagname(attr1='value1' attr2='value2') Contents
+
 Adding `class` and `id` attributes is even easier.
 Haml uses the same syntax as the CSS that styles the document:
 

data/VERSION

@@ -1 +1 @@
-2.1.44
+2.1.45

data/extra/haml-mode.el

@@ -61,8 +61,12 @@ if the next line could be nested within this line.
 The function can also return a positive integer to indicate
 a specific level to which the current line could be indented.")
 
+(defconst haml-tag-beg-re
+  "^ *\\(?:[%\\.#][a-z0-9_:\\-]*\\)+\\(?:(.*)\\|{.*}\\|\\[.*\\]\\)*"
+  "A regexp matching the beginning of a Haml tag, through (), {}, and [].")
+
 (defvar haml-block-openers
-  `("^ *\\([%\\.#][a-z0-9_:\\-]*\\)+\\({.*}\\)?\\(\\[.*\\]\\)?[><]*[ \t]*$"
+  `(,(concat haml-tag-beg-re "[><]*[ \t]*$")
     "^ *[&!]?[-=~].*do[ \t]*\\(|.*|[ \t]*\\)?$"
     ,(concat "^ *[&!]?[-=~][ \t]*\\("
              (regexp-opt '("if" "unless" "while" "until" "else"
@@ -122,53 +126,73 @@ For example, this will highlight all of the following:
   %p= 'baz'
   %p{:foo => 'bar'}[@bar]= 'baz'"
   (when (re-search-forward "^ *[%.#]" limit t)
-    (let ((eol (save-excursion (end-of-line) (point))))
+    (forward-char -1)
+
+    ;; Highlight tag, classes, and ids
+    (while (haml-move "\\([.#%]\\)[a-z0-9_:\\-]*")
+      (put-text-property (match-beginning 0) (match-end 0) 'face
+                         (case (char-after (match-beginning 1))
+                           (?% font-lock-function-name-face)
+                           (?# font-lock-keyword-face)
+                           (?. font-lock-type-face))))
+
+    (block loop
+      (while t
+        (let ((eol (save-excursion (end-of-line) (point))))
+          (case (char-after)
+            ;; Highlight obj refs
+            (?\[
+             (let ((beg (point)))
+               (haml-limited-forward-sexp eol)
+               (haml-fontify-region-as-ruby beg (point))))
+            ;; Highlight new attr hashes
+            (?\(
+             (forward-char 1)
+             (while
+                 (and (haml-parse-new-attr-hash
+                       (lambda (type beg end)
+                         (case type
+                           (name (put-text-property beg end 'face font-lock-constant-face))
+                           (value (haml-fontify-region-as-ruby beg end)))))
+                      (not (eobp)))
+               (forward-line 1)
+               (beginning-of-line)))
+            ;; Highlight old attr hashes
+            (?\{
+             (let ((beg (point)))
+               (haml-limited-forward-sexp eol)
+
+               ;; Check for multiline
+               (while (and (eolp) (eq (char-before) ?,) (not (eobp)))
+                 (forward-line)
+                 (let ((eol (save-excursion (end-of-line) (point))))
+                   ;; If no sexps are closed,
+                   ;; we're still continuing a  multiline hash
+                   (if (>= (car (parse-partial-sexp (point) eol)) 0)
+                       (end-of-line)
+                     ;; If sexps have been closed,
+                     ;; set the point at the end of the total sexp
+                     (goto-char beg)
+                     (haml-limited-forward-sexp eol))))
+
+               (haml-fontify-region-as-ruby (+ 1 beg) (point))))
+            (t (return-from loop))))))
+
+    ;; Move past end chars
+    (when (looking-at "[<>&!]+") (goto-char (match-end 0)))
+    ;; Highlight script
+    (if (looking-at "\\([=~]\\) \\(.*\\)$")
+        (haml-fontify-region-as-ruby (match-beginning 2) (match-end 2))
+      ;; Give font-lock something to highlight
       (forward-char -1)
+      (looking-at "\\(\\)"))
+    t))
 
-      ;; Highlight tag, classes, and ids
-      (while (looking-at "[.#%][a-z0-9_:\\-]*")
-        (put-text-property (match-beginning 0) (match-end 0) 'face
-                           (case (char-after)
-                             (?% font-lock-function-name-face)
-                             (?# font-lock-keyword-face)
-                             (?. font-lock-type-face)))
-        (goto-char (match-end 0)))
-
-      ;; Highlight obj refs
-      (when (eq (char-after) ?\[)
-        (let ((beg (point)))
-          (haml-limited-forward-sexp eol)
-          (haml-fontify-region-as-ruby beg (point))))
-
-      ;; Highlight attr hashes
-      (when (eq (char-after) ?\{)
-        (let ((beg (point)))
-          (haml-limited-forward-sexp eol)
-
-          ;; Check for multiline
-          (while (and (eolp) (eq (char-before) ?,) (not (eobp)))
-            (forward-line)
-            (let ((eol (save-excursion (end-of-line) (point))))
-              ;; If no sexps are closed,
-              ;; we're still continuing a  multiline hash
-              (if (>= (car (parse-partial-sexp (point) eol)) 0)
-                  (end-of-line)
-                ;; If sexps have been closed,
-                ;; set the point at the end of the total sexp
-                (goto-char beg)
-                (haml-limited-forward-sexp eol))))
-
-          (haml-fontify-region-as-ruby (+ 1 beg) (point))))
-
-      ;; Move past end chars
-      (when (looking-at "[<>&!]+") (goto-char (match-end 0)))
-      ;; Highlight script
-      (if (looking-at "\\([=~]\\) \\(.*\\)$")
-          (haml-fontify-region-as-ruby (match-beginning 2) (match-end 2))
-        ;; Give font-lock something to highlight
-        (forward-char -1)
-        (looking-at "\\(\\)"))
-      t)))
+(defun haml-move (re)
+  "Try matching and moving to the end of a regular expression."
+  (when (looking-at re)
+    (goto-char (match-end 0))
+    t))
 
 (defun haml-highlight-interpolation (limit)
   "Highlight Ruby interpolation (#{foo})."
@@ -441,10 +465,8 @@ character of the next line."
   "Returns t if the current line can have lines nested beneath it."
   (let ((attr-props (haml-parse-multiline-attr-hash)))
     (when attr-props
-      (end-of-line)
       (return-from haml-indent-p
-        (if (eq (char-before) ?,) (cdr (assq 'hash-indent attr-props))
-          (beginning-of-line)
+        (if (haml-unclosed-attr-hash-p) (cdr (assq 'hash-indent attr-props))
           (list (+ (cdr (assq 'indent attr-props)) haml-indent-offset) nil)))))
   (loop for opener in haml-block-openers
         if (looking-at opener) return t
@@ -464,20 +486,51 @@ beginning the hash."
   (save-excursion
     (while t
       (beginning-of-line)
-      (if (looking-at "^ *\\(?:[.#%][a-z0-9_:\\-]+\\)+{")
+      (if (looking-at (eval-when-compile (concat haml-tag-beg-re "\\([{(]\\)")))
           (progn
             (goto-char (- (match-end 0) 1))
             (haml-limited-forward-sexp (save-excursion (end-of-line) (point)))
             (return-from haml-parse-multiline-attr-hash
-              (if (eq (char-before) ?,)
-                  `((indent . ,(current-indentation))
-                    (hash-indent . ,(- (match-end 0) (match-beginning 0)))
-                    (point . ,(match-beginning 0)))
-                nil)))
+              (when (or (string-equal (match-string 1) "(") (eq (char-before) ?,))
+                `((indent . ,(current-indentation))
+                  (hash-indent . ,(- (match-end 0) (match-beginning 0)))
+                  (point . ,(match-beginning 0))))))
+        (when (bobp) (return-from haml-parse-multiline-attr-hash))
         (forward-line -1)
-        (end-of-line)
-        (when (not (eq (char-before) ?,))
-          (return-from haml-parse-multiline-attr-hash nil))))))
+        (unless (haml-unclosed-attr-hash-p)
+          (return-from haml-parse-multiline-attr-hash))))))
+
+(defun* haml-unclosed-attr-hash-p ()
+  "Return t if this line has an unclosed attribute hash, new or old."
+  (save-excursion
+    (end-of-line)
+    (when (eq (char-before) ?,) (return-from haml-unclosed-attr-hash-p t))
+    (re-search-backward "(\\|^")
+    (haml-move "(")
+    (haml-parse-new-attr-hash)))  
+
+(defun* haml-parse-new-attr-hash (&optional (fn (lambda (type beg end) ())))
+  "Parse a new-style attribute hash on this line, and returns
+t if it's not finished on the current line.
+
+FN should take three parameters: TYPE, BEG, and END.
+TYPE is the type of text parsed ('name or 'value)
+and BEG and END delimit that text in the buffer."
+  (let ((eol (save-excursion (end-of-line) (point))))
+    (while (not (haml-move ")"))
+      (haml-move " *")
+      (unless (haml-move "[a-z0-9_:\\-]+")
+        (return-from haml-parse-new-attr-hash (haml-move " *$")))
+      (funcall fn 'name (match-beginning 0) (match-end 0))
+      (haml-move " *")
+      (when (haml-move "=")
+        (haml-move " *")
+        (unless (looking-at "[\"'@a-z]") (return-from haml-parse-new-attr-hash))
+        (let ((beg (point)))
+          (haml-limited-forward-sexp eol)
+          (funcall fn 'value beg (point)))
+        (haml-move " *")))
+    nil))
 
 (defun haml-compute-indentation ()
   "Calculate the maximum sensible indentation for the current line."

data/lib/haml/buffer.rb

@@ -252,7 +252,7 @@ RUBY
 
       if to['class'] && from['class']
         # Make sure we don't duplicate class names
-        from['class'] = (from['class'].split(' ') | to['class'].split(' ')).join(' ')
+        from['class'] = (from['class'].split(' ') | to['class'].split(' ')).sort.join(' ')
       elsif to['class'] || from['class']
         from['class'] ||= to['class']
       end

data/lib/haml/precompiler.rb

@@ -456,8 +456,6 @@ END
     end
 
     def parse_static_hash(text)
-      return {} unless text
-
       attributes = {}
       scanner = StringScanner.new(text)
       scanner.scan(/\s+/)
@@ -512,21 +510,38 @@ END
     def parse_tag(line)
       raise SyntaxError.new("Invalid tag: \"#{line}\".") unless match = line.scan(/%([-:\w]+)([-\w\.\#]*)(.*)/)[0]
       tag_name, attributes, rest = match
-      attributes_hash, rest, last_line = parse_attributes(rest) if rest[0] == ?{
+      new_attributes_hash = old_attributes_hash = last_line = object_ref = nil
+      attributes_hashes = []
+      while rest
+        case rest[0]
+        when ?{
+          break if old_attributes_hash
+          old_attributes_hash, rest, last_line = parse_old_attributes(rest)
+          attributes_hashes << [:old, old_attributes_hash]
+        when ?(
+          break if new_attributes_hash
+          new_attributes_hash, rest, last_line = parse_new_attributes(rest)
+          attributes_hashes << [:new, new_attributes_hash]
+        when ?[
+          break if object_ref
+          object_ref, rest = balance(rest, ?[, ?])
+        else; break
+        end
+      end
+
       if rest
-        object_ref, rest = balance(rest, ?[, ?]) if rest[0] == ?[
-        attributes_hash, rest, last_line = parse_attributes(rest) if rest[0] == ?{ && attributes_hash.nil?
         nuke_whitespace, action, value = rest.scan(/(<>|><|[><])?([=\/\~&!])?(.*)?/)[0]
         nuke_whitespace ||= ''
         nuke_outer_whitespace = nuke_whitespace.include? '>'
         nuke_inner_whitespace = nuke_whitespace.include? '<'
       end
+
       value = value.to_s.strip
-      [tag_name, attributes, attributes_hash, object_ref, nuke_outer_whitespace,
+      [tag_name, attributes, attributes_hashes, object_ref, nuke_outer_whitespace,
        nuke_inner_whitespace, action, value, last_line || @index]
     end
 
-    def parse_attributes(line)
+    def parse_old_attributes(line)
       line = line.dup
       last_line = @index
 
@@ -547,10 +562,77 @@ END
       return attributes_hash, rest, last_line
     end
 
+    def parse_new_attributes(line)
+      line = line.dup
+      scanner = StringScanner.new(line)
+      last_line = @index
+      attributes = {}
+
+      scanner.scan(/\(\s*/)
+      until (name, value = parse_new_attribute(scanner)).first.nil?
+        if name == false
+          text = (Haml::Shared.balance(line, ?(, ?)) || [line]).first
+          raise Haml::SyntaxError.new("Invalid attribute list: #{text.inspect}.", last_line - 1)
+        end
+        attributes[name] = value
+        scanner.scan(/\s*/)
+
+        if scanner.eos?
+          line << " " << @next_line.text
+          last_line += 1
+          next_line
+          scanner.scan(/\s*/)
+        end
+      end
+
+      static_attributes = {}
+      dynamic_attributes = "{"
+      attributes.each do |name, (type, val)|
+        if type == :static
+          static_attributes[name] = val
+        else
+          dynamic_attributes << name.inspect << " => " << val << ","
+        end
+      end
+      dynamic_attributes << "}"
+      dynamic_attributes = nil if dynamic_attributes == "{}"
+
+      return [static_attributes, dynamic_attributes], scanner.rest, last_line
+    end
+
+    def parse_new_attribute(scanner)
+      unless name = scanner.scan(/[-:\w]+/)
+        return if scanner.scan(/\)/)
+        return false
+      end
+
+      scanner.scan(/\s*/)
+      return name, [:static, true] unless scanner.scan(/=/) #/end
+
+      scanner.scan(/\s*/)
+      unless quote = scanner.scan(/["']/)
+        return false unless var = scanner.scan(/(@@?|\$)?\w+/)
+        return name, [:dynamic, var]
+      end
+
+      re = /((?:\\.|\#[^{]|[^#{quote}\\#])*)(#{quote}|#\{)/
+      content = []
+      loop do
+        return false unless scanner.scan(re)
+        content << [:str, scanner[1].gsub(/\\(.)/, '\1')]
+        break if scanner[2] == quote
+        content << [:ruby, balance(scanner, ?{, ?}, 1).first[0...-1]]
+      end
+
+      return name, [:static, content.first[1]] if content.size == 1
+      return name, [:dynamic,
+        '"' + content.map {|(t, v)| t == :str ? v.inspect[1...-1] : "\#{#{v}}"}.join + '"']
+    end
+
     # Parses a line that will render as an XHTML tag, and adds the code that will
     # render that tag to <tt>@precompiled</tt>.
     def render_tag(line)
-      tag_name, attributes, attributes_hash, object_ref, nuke_outer_whitespace,
+      tag_name, attributes, attributes_hashes, object_ref, nuke_outer_whitespace,
         nuke_inner_whitespace, action, value, last_line = parse_tag(line)
 
       raise SyntaxError.new("Illegal element: classes and ids must have values.") if attributes =~ /[\.#](\.|#|\z)/
@@ -597,10 +679,17 @@ END
 
       object_ref = "nil" if object_ref.nil? || @options[:suppress_eval]
 
-      static_attributes = parse_static_hash(attributes_hash) # Try pre-compiling a static attributes hash
-      attributes_hash = nil if static_attributes || @options[:suppress_eval]
       attributes = parse_class_and_id(attributes)
-      Buffer.merge_attrs(attributes, static_attributes) if static_attributes
+      attributes_hashes.map! do |syntax, attributes_hash|
+        if syntax == :old
+          static_attributes = parse_static_hash(attributes_hash)
+          attributes_hash = nil if static_attributes || @options[:suppress_eval]
+        else
+          static_attributes, attributes_hash = attributes_hash
+        end
+        Buffer.merge_attrs(attributes, static_attributes) if static_attributes
+        attributes_hash
+      end.compact!
 
       raise SyntaxError.new("Illegal nesting: nesting within a self-closing tag is illegal.", @next_line.index) if block_opened? && self_closing
       raise SyntaxError.new("Illegal nesting: content can't be both given on the same line as %#{tag_name} and nested within it.", @next_line.index) if block_opened? && !value.empty?
@@ -614,7 +703,7 @@ END
         (nuke_inner_whitespace && block_opened?)
 
       # Check if we can render the tag directly to text and not process it in the buffer
-      if object_ref == "nil" && attributes_hash.nil? && !preserve_script
+      if object_ref == "nil" && attributes_hashes.empty? && !preserve_script
         tag_closed = !block_opened? && !self_closing && !parse
 
         open_tag  = prerender_tag(tag_name, self_closing, attributes)
@@ -633,11 +722,18 @@ END
       else
         flush_merged_text
         content = value.empty? || parse ? 'nil' : value.dump
-        attributes_hash = ', ' + attributes_hash if attributes_hash
+        if attributes_hashes.empty?
+          attributes_hashes = ''
+        elsif attributes_hashes.size == 1
+          attributes_hashes = ", #{attributes_hashes.first}"
+        else
+          attributes_hashes = ", (#{attributes_hashes.join(").merge(")})"
+        end
+
         args = [tag_name, self_closing, !block_opened?, preserve_tag, escape_html,
                 attributes, nuke_outer_whitespace, nuke_inner_whitespace
                ].map { |v| v.inspect }.join(', ')
-        push_silent "_hamlout.open_tag(#{args}, #{object_ref}, #{content}#{attributes_hash})"
+        push_silent "_hamlout.open_tag(#{args}, #{object_ref}, #{content}#{attributes_hashes})"
         @dont_tab_up_next_text = @dont_indent_next_line = dont_indent_next_line
       end
 

data/lib/sass/script/number.rb

@@ -269,9 +269,9 @@ module Sass::Script
     # An incompatible coercion, e.g. between px and cm, will raise an error.
     #
     # @param num_units [Array<String>] The numerator units to coerce this number into.
-    #   See {#numerator\_units}
+    #   See {\#numerator\_units}
     # @param den_units [Array<String>] The denominator units to coerce this number into.
-    #   See {#denominator\_units}
+    #   See {\#denominator\_units}
     # @return [Number] The number with the new units
     # @raise [Sass::UnitConversionError] if the given units are incompatible with the number's
     #   current units

data/test/haml/engine_test.rb

@@ -23,6 +23,7 @@ class EngineTest < Test::Unit::TestCase
     "." => "Illegal element: classes and ids must have values.",
     ".#" => "Illegal element: classes and ids must have values.",
     ".{} a" => "Illegal element: classes and ids must have values.",
+    ".() a" => "Illegal element: classes and ids must have values.",
     ".= a" => "Illegal element: classes and ids must have values.",
     "%p..a" => "Illegal element: classes and ids must have values.",
     "%a/ b" => "Self-closing tags can't have content.",
@@ -47,6 +48,12 @@ class EngineTest < Test::Unit::TestCase
     "%p\n  foo\n%p\n    bar" => ["The line was indented 2 levels deeper than the previous line.", 4],
     "%p\n  foo\n  %p\n        bar" => ["The line was indented 3 levels deeper than the previous line.", 4],
     "%p\n \tfoo" => ["Indentation can't use both tabs and spaces.", 2],
+    "%p(" => "Invalid attribute list: \"(\".",
+    "%p(foo=\nbar)" => ["Invalid attribute list: \"(foo=\".", 1],
+    "%p(foo=)" => "Invalid attribute list: \"(foo=)\".",
+    "%p(foo 'bar')" => "Invalid attribute list: \"(foo 'bar')\".",
+    "%p(foo 'bar'\nbaz='bang')" => ["Invalid attribute list: \"(foo 'bar'\".", 1],
+    "%p(foo='bar'\nbaz 'bang'\nbip='bop')" => ["Invalid attribute list: \"(foo='bar' baz 'bang'\".", 2],
 
     # Regression tests
     "- raise 'foo'\n\n\n\nbar" => ["foo", 1],
@@ -805,6 +812,104 @@ END
     assert_equal %{<!DOCTYPE html>\n}, render('!!!', :format => :html5)
   end
 
+  # New attributes
+
+  def test_basic_new_attributes
+    assert_equal("<a>bar</a>\n", render("%a() bar"))
+    assert_equal("<a href='foo'>bar</a>\n", render("%a(href='foo') bar"))
+    assert_equal("<a b='c' c='d' d='e'>baz</a>\n", render(%q{%a(b="c" c='d' d="e") baz}))
+  end
+
+  def test_new_attribute_ids
+    assert_equal("<div id='foo_bar'></div>\n", render("#foo(id='bar')"))
+    assert_equal("<div id='foo_bar_baz'></div>\n", render("#foo{:id => 'bar'}(id='baz')"))
+    assert_equal("<div id='foo_baz_bar'></div>\n", render("#foo(id='baz'){:id => 'bar'}"))
+    foo = User.new(42)
+    assert_equal("<div class='struct_user' id='foo_baz_bar_struct_user_42'></div>\n",
+      render("#foo(id='baz'){:id => 'bar'}[foo]", :locals => {:foo => foo}))
+    assert_equal("<div class='struct_user' id='foo_baz_bar_struct_user_42'></div>\n",
+      render("#foo(id='baz')[foo]{:id => 'bar'}", :locals => {:foo => foo}))
+    assert_equal("<div class='struct_user' id='foo_baz_bar_struct_user_42'></div>\n",
+      render("#foo[foo](id='baz'){:id => 'bar'}", :locals => {:foo => foo}))
+    assert_equal("<div class='struct_user' id='foo_bar_baz_struct_user_42'></div>\n",
+      render("#foo[foo]{:id => 'bar'}(id='baz')", :locals => {:foo => foo}))
+  end
+
+  def test_new_attribute_classes
+    assert_equal("<div class='bar foo'></div>\n", render(".foo(class='bar')"))
+    assert_equal("<div class='bar baz foo'></div>\n", render(".foo{:class => 'bar'}(class='baz')"))
+    assert_equal("<div class='bar baz foo'></div>\n", render(".foo(class='baz'){:class => 'bar'}"))
+    foo = User.new(42)
+    assert_equal("<div class='bar baz foo struct_user' id='struct_user_42'></div>\n",
+      render(".foo(class='baz'){:class => 'bar'}[foo]", :locals => {:foo => foo}))
+    assert_equal("<div class='bar baz foo struct_user' id='struct_user_42'></div>\n",
+      render(".foo[foo](class='baz'){:class => 'bar'}", :locals => {:foo => foo}))
+    assert_equal("<div class='bar baz foo struct_user' id='struct_user_42'></div>\n",
+      render(".foo[foo]{:class => 'bar'}(class='baz')", :locals => {:foo => foo}))
+  end
+
+  def test_dynamic_new_attributes
+    assert_equal("<a href='12'>bar</a>\n", render("%a(href=foo) bar", :locals => {:foo => 12}))
+    assert_equal("<a b='12' c='13' d='14'>bar</a>\n", render("%a(b=b c='13' d=d) bar", :locals => {:b => 12, :d => 14}))
+  end
+
+  def test_new_attribute_interpolation
+    assert_equal("<a href='12'>bar</a>\n", render('%a(href="1#{1 + 1}") bar'))
+    assert_equal("<a href='2: 2, 3: 3'>bar</a>\n", render(%q{%a(href='2: #{1 + 1}, 3: #{foo}') bar}, :locals => {:foo => 3}))
+    assert_equal(%Q{<a href='1\#{1 + 1}'>bar</a>\n}, render('%a(href="1\#{1 + 1}") bar'))
+  end
+
+  def test_truthy_new_attributes
+    assert_equal("<a href='href'>bar</a>\n", render("%a(href) bar"))
+    assert_equal("<a bar='baz' href>bar</a>\n", render("%a(href bar='baz') bar", :format => :html5))
+    assert_equal("<a href='href'>bar</a>\n", render("%a(href=true) bar"))
+    assert_equal("<a>bar</a>\n", render("%a(href=false) bar"))
+  end
+
+  def test_new_attribute_parsing
+    assert_equal("<a a2='b2'>bar</a>\n", render("%a(a2=b2) bar", :locals => {:b2 => 'b2'}))
+    assert_equal(%Q{<a a='foo"bar'>bar</a>\n}, render(%q{%a(a="#{'foo"bar'}") bar})) #'
+    assert_equal(%Q{<a a="foo'bar">bar</a>\n}, render(%q{%a(a="#{"foo'bar"}") bar})) #'
+    assert_equal(%Q{<a a='foo"bar'>bar</a>\n}, render(%q{%a(a='foo"bar') bar}))
+    assert_equal(%Q{<a a="foo'bar">bar</a>\n}, render(%q{%a(a="foo'bar") bar}))
+    assert_equal("<a a:b='foo'>bar</a>\n", render("%a(a:b='foo') bar"))
+    assert_equal("<a a='foo' b='bar'>bar</a>\n", render("%a(a = 'foo' b = 'bar') bar"))
+    assert_equal("<a a='foo' b='bar'>bar</a>\n", render("%a(a = foo b = bar) bar", :locals => {:foo => 'foo', :bar => 'bar'}))
+    assert_equal("<a a='foo'>(b='bar')</a>\n", render("%a(a='foo')(b='bar')"))
+    assert_equal("<a a='foo)bar'>baz</a>\n", render("%a(a='foo)bar') baz"))
+    assert_equal("<a a='foo'>baz</a>\n", render("%a( a = 'foo' ) baz"))
+  end
+
+  def test_new_attribute_escaping
+    assert_equal(%Q{<a a='foo " bar'>bar</a>\n}, render(%q{%a(a="foo \" bar") bar}))
+    assert_equal(%Q{<a a='foo \\" bar'>bar</a>\n}, render(%q{%a(a="foo \\\\\" bar") bar}))
+
+    assert_equal(%Q{<a a="foo ' bar">bar</a>\n}, render(%q{%a(a='foo \' bar') bar}))
+    assert_equal(%Q{<a a="foo \\' bar">bar</a>\n}, render(%q{%a(a='foo \\\\\' bar') bar}))
+
+    assert_equal(%Q{<a a='foo \\ bar'>bar</a>\n}, render(%q{%a(a="foo \\\\ bar") bar}))
+    assert_equal(%Q{<a a='foo \#{1 + 1} bar'>bar</a>\n}, render(%q{%a(a="foo \#{1 + 1} bar") bar}))
+  end
+
+  def test_multiline_new_attribute
+    assert_equal("<a a='b' c='d'>bar</a>\n", render("%a(a='b'\n  c='d') bar"))
+    assert_equal("<a a='b' b='c' c='d' d='e' e='f' f='j'>bar</a>\n",
+      render("%a(a='b' b='c'\n  c='d' d=e\n  e='f' f='j') bar", :locals => {:e => 'e'}))
+  end
+
+  def test_new_and_old_attributes
+    assert_equal("<a a='b' c='d'>bar</a>\n", render("%a(a='b'){:c => 'd'} bar"))
+    assert_equal("<a a='b' c='d'>bar</a>\n", render("%a{:c => 'd'}(a='b') bar"))
+    assert_equal("<a a='b' c='d'>bar</a>\n", render("%a(c='d'){:a => 'b'} bar"))
+    assert_equal("<a a='b' c='d'>bar</a>\n", render("%a{:a => 'b'}(c='d') bar"))
+
+    assert_equal("<a a='d'>bar</a>\n", render("%a{:a => 'b'}(a='d') bar"))
+    assert_equal("<a a='b'>bar</a>\n", render("%a(a='d'){:a => 'b'} bar"))
+
+    assert_equal("<a a='b' b='c' c='d' d='e'>bar</a>\n",
+      render("%a{:a => 'b',\n:b => 'c'}(c='d'\nd='e') bar"))
+  end
+
   # Encodings
 
   unless Haml::Util.ruby1_8?

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: haml-edge
 version: !ruby/object:Gem::Version 
-  version: 2.1.44
+  version: 2.1.45
 platform: ruby
 authors: 
 - Nathan Weizenbaum
@@ -12,8 +12,27 @@ cert_chain: []
 
 date: 2009-07-04 00:00:00 -04:00
 default_executable: 
-dependencies: []
-
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: yard
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 0.2.3
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: maruku
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 0.5.9
+    version: 
 description: Haml (HTML Abstraction Markup Language) is a layer on top of XHTML or XML that's designed to express the structure of XHTML or XML documents in a non-repetitive, elegant, easy way, using indentation rather than closing tags and allowing Ruby to be embedded with ease. It was originally envisioned as a plugin for Ruby on Rails, but it can function as a stand-alone templating engine.
 email: haml@googlegroups.com
 executables: