haml-edge 2.3.209 → 2.3.210

data/lib/sass/tree/prop_node.rb

@@ -68,28 +68,19 @@ module Sass::Tree
     # This only applies for old-style properties with no value,
     # so returns the empty string if this is new-style.
     #
-    # This should only be called once \{#perform} has been called.
-    #
     # @return [String] The message
     def pseudo_class_selector_message
-      return "" if @prop_syntax == :new || !resolved_value.empty?
+      return "" if @prop_syntax == :new || !value.is_a?(Sass::Script::String) || !value.value.empty?
       "\nIf #{declaration.dump} should be a selector, use \"\\#{declaration}\" instead."
     end
 
     protected
 
+    # @see Node#to_src
     def to_src(tabs, opts, fmt)
-      name = self.name.map {|n| n.is_a?(String) ? n : "\#{#{n.to_sass(opts)}}"}.join
-      if name[0] == ?:
-        raise Sass::SyntaxError.new("The \":#{name}: #{self.class.val_to_sass(value, opts)}\" hack is not allowed in the Sass indented syntax")
-      end
-
-      old = opts[:old] && fmt == :sass
-      initial = old ? ':' : ''
-      mid = old ? '' : ':'
-      res = "#{'  ' * tabs}#{initial}#{name}#{mid} #{self.class.val_to_sass(value, opts)}"
+      res = declaration(tabs, opts, fmt)
       return res + "#{semi fmt}\n" if children.empty?
-      res.rstrip + children_to_src(tabs, opts, fmt).rstrip + semi(fmt) + "\n"
+      res + children_to_src(tabs, opts, fmt).rstrip + semi(fmt) + "\n"
     end
 
     # Computes the CSS for the property.
@@ -103,10 +94,12 @@ module Sass::Tree
 
     # Converts nested properties into flat properties.
     #
+    # @param extends [Haml::Util::SubsetMap{Selector::Simple => Selector::Sequence}]
+    #   The extensions defined for this tree
     # @param parent [PropNode, nil] The parent node of this node,
     #   or nil if the parent isn't a {PropNode}
     # @raise [Sass::SyntaxError] if the property uses invalid syntax
-    def _cssize(parent)
+    def _cssize(extends, parent)
       node = super
       result = node.children.dup
       if !node.resolved_value.empty? || node.children.empty?
@@ -119,9 +112,11 @@ module Sass::Tree
     # Updates the name and indentation of this node based on the parent name
     # and nesting level.
     #
+    # @param extends [Haml::Util::SubsetMap{Selector::Simple => Selector::Sequence}]
+    #   The extensions defined for this tree
     # @param parent [PropNode, nil] The parent node of this node,
     #   or nil if the parent isn't a {PropNode}
-    def cssize!(parent)
+    def cssize!(extends, parent)
       self.resolved_name = "#{parent.resolved_name}-#{resolved_name}" if parent
       self.tabs = parent.tabs + (parent.resolved_value.empty? ? 0 : 1) if parent && style == :nested
       super
@@ -169,12 +164,16 @@ module Sass::Tree
       end
     end
 
-    def declaration
-      if @prop_syntax == :new
-        "#{resolved_name}: #{resolved_value}"
-      else
-        ":#{resolved_name} #{resolved_value}"
-      end.strip
+    def declaration(tabs = 0, opts = {:old => @prop_syntax == :old}, fmt = :sass)
+      name = self.name.map {|n| n.is_a?(String) ? n : "\#{#{n.to_sass(opts)}}"}.join
+      if name[0] == ?:
+        raise Sass::SyntaxError.new("The \":#{name}: #{self.class.val_to_sass(value, opts)}\" hack is not allowed in the Sass indented syntax")
+      end
+
+      old = opts[:old] && fmt == :sass
+      initial = old ? ':' : ''
+      mid = old ? '' : ':'
+      "#{'  ' * tabs}#{initial}#{name}#{mid} #{self.class.val_to_sass(value, opts)}".rstrip
     end
 
     class << self

data/lib/sass/tree/root_node.rb

@@ -62,6 +62,7 @@ module Sass
 
       protected
 
+      # @see Node#to_src
       def to_src(opts, fmt)
         Haml::Util.enum_cons(children + [nil], 2).map do |child, nxt|
           child.send("to_#{fmt}", 0, opts) +
@@ -75,20 +76,6 @@ module Sass
         end.join.rstrip + "\n"
       end
 
-      # Destructively converts this static Sass node into a static CSS node,
-      # and checks that there are no properties at root level.
-      #
-      # @param parent [Node, nil] The parent node of this node.
-      #   This should only be non-nil if the parent is the same class as this node
-      # @see Node#cssize!
-      def cssize!(parent)
-        super
-        return unless child = children.find {|c| c.is_a?(PropNode)}
-        message = "Properties aren't allowed at the root of a document." +
-          child.pseudo_class_selector_message
-        raise Sass::SyntaxError.new(message, :line => child.line)
-      end
-
       # Computes the CSS corresponding to this Sass tree.
       #
       # @param args [Array] ignored
@@ -106,12 +93,16 @@ module Sass
         return result + "\n"
       end
 
-      # Returns false, because all nodes are allowed at the root of the document
-      # (properties are detected elsewhere post-mixin-resolution).
+      # Returns an error message if the given child node is invalid,
+      # and false otherwise.
+      #
+      # Only property nodes are invalid at root level.
       #
       # @see Node#invalid_child?
       def invalid_child?(child)
-        false
+        return unless child.is_a?(Tree::PropNode)
+        "Properties aren't allowed at the root of a document." +
+          child.pseudo_class_selector_message
       end
     end
   end

data/lib/sass/tree/rule_node.rb

@@ -7,7 +7,6 @@ module Sass::Tree
   # @see Sass::Tree
   class RuleNode < Node
     # The character used to include the parent selector
-    # @private
     PARENT = '&'
 
     # The CSS selector for this rule,
@@ -18,44 +17,19 @@ module Sass::Tree
     # @return [Array<String, Sass::Script::Node>]
     attr_accessor :rule
 
-    # The CSS selectors for this rule,
-    # parsed for commas and parent-references.
+    # The CSS selector for this rule,
+    # without any unresolved interpolation
+    # but with parent references still intact.
     # It's only set once {Tree::Node#perform} has been called.
     #
-    # It's an array of arrays.
-    # The first level of arrays comma-separated selectors;
-    # the second represents structure within those selectors,
-    # currently only parent-refs (represented by `:parent`).
-    # Newlines are represented as literal `\n` characters in the strings.
-    # For example,
-    #
-    #     &.foo, bar, baz,
-    #     bip, &.bop, bup
-    #
-    # would be
-    #
-    #     [[:parent, ".foo"], ["bar"], ["baz"],
-    #      ["\nbip"], [:parent, ".bop"], ["bup"]]
-    #
-    # @return [Array<Array<String, Symbol>>]
+    # @return [Selector::CommaSequence]
     attr_accessor :parsed_rules
 
-    # The CSS selectors for this rule,
-    # with all nesting and parent references resolved.
+    # The CSS selector for this rule,
+    # without any unresolved interpolation or parent references.
     # It's only set once {Tree::Node#cssize} has been called.
     #
-    # Each element is a distinct selector, separated by commas.
-    # Newlines are represented as literal `\n` characters in the strings.
-    # For example,
-    #
-    #     foo bar, baz,
-    #     bang, bip bop, blip
-    #
-    # would be
-    #
-    #     ["foo bar", "baz", "\nbang", "bip bop", "blip"]
-    #
-    # @return [Array<String>]
+    # @return [Selector::CommaSequence]
     attr_accessor :resolved_rules
 
     # How deep this rule is indented
@@ -121,6 +95,7 @@ module Sass::Tree
       name.gsub(/^/, '  ' * tabs) + children_to_src(tabs, opts, :sass)
     end
 
+    # @see Node#to_scss
     def to_scss(tabs, opts = {})
       name = rule.map {|r| r.is_a?(String) ? r : "\#{#{r.to_sass(opts)}}"}.
         join.gsub(/^[ \t]*/, '  ' * tabs)
@@ -135,6 +110,15 @@ module Sass::Tree
       res
     end
 
+    # Extends this Rule's selector with the given `extends`.
+    #
+    # @see Node#do_extend
+    def do_extend(extends)
+      node = dup
+      node.resolved_rules = resolved_rules.do_extend(extends)
+      node
+    end
+
     protected
 
     # Computes the CSS for the rule.
@@ -154,7 +138,9 @@ module Sass::Tree
       rule_indent = '  ' * (tabs - 1)
       per_rule_indent, total_indent = [:nested, :expanded].include?(style) ? [rule_indent, ''] : ['', rule_indent]
 
-      total_rule = total_indent + resolved_rules.join(rule_separator).split("\n").map do |line|
+      total_rule = total_indent + resolved_rules.members.
+        map {|seq| seq.to_a.join}.
+        join(rule_separator).split("\n").map do |line|
         per_rule_indent + line.strip
       end.join(line_separator)
 
@@ -199,21 +185,24 @@ module Sass::Tree
       to_return
     end
 
-    # Runs any SassScript that may be embedded in the rule,
-    # and parses the selectors for commas.
+    # Runs SassScript interpolation in the selector,
+    # and then parses the result into a {Sass::Selector::CommaSequence}.
     #
     # @param environment [Sass::Environment] The lexical environment containing
     #   variable and mixin values
     def perform!(environment)
-      @parsed_rules = parse_selector(run_interp(@rule, environment))
+      @parsed_rules = Sass::SCSS::StaticParser.new(run_interp(@rule, environment)).
+        parse_selector(self.line, self.filename)
       super
     end
 
     # Converts nested rules into a flat list of rules.
     #
+    # @param extends [Haml::Util::SubsetMap{Selector::Simple => Selector::Sequence}]
+    #   The extensions defined for this tree
     # @param parent [RuleNode, nil] The parent node of this node,
     #   or nil if the parent isn't a {RuleNode}
-    def _cssize(parent)
+    def _cssize(extends, parent)
       node = super
       rules = node.children.select {|c| c.is_a?(RuleNode)}
       props = node.children.reject {|c| c.is_a?(RuleNode) || c.invisible?}
@@ -232,14 +221,28 @@ module Sass::Tree
     # Resolves parent references and nested selectors,
     # and updates the indentation based on the parent's indentation.
     #
+    # @param extends [Haml::Util::SubsetMap{Selector::Simple => Selector::Sequence}]
+    #   The extensions defined for this tree
     # @param parent [RuleNode, nil] The parent node of this node,
     #   or nil if the parent isn't a {RuleNode}
     # @raise [Sass::SyntaxError] if the rule has no parents but uses `&`
-    def cssize!(parent)
-      self.resolved_rules = resolve_parent_refs(parent && parent.resolved_rules)
+    def cssize!(extends, parent)
+      self.resolved_rules = @parsed_rules.resolve_parent_refs(parent && parent.resolved_rules)
       super
     end
 
+    # Returns an error message if the given child node is invalid,
+    # and false otherwise.
+    #
+    # {ExtendNode}s are valid within {RuleNode}s.
+    #
+    # @param child [Tree::Node] A potential child nodecompact.
+    # @return [Boolean, String] Whether or not the child node is valid,
+    #   as well as the error message to display if it is invalid
+    def invalid_child?(child)
+      super unless child.is_a?(ExtendNode)
+    end
+
     # A hash that will be associated with this rule in the CSS document
     # if the {file:SASS_REFERENCE.md#debug_info-option `:debug_info` option} is enabled.
     # This data is used by e.g. [the FireSass Firebug extension](https://addons.mozilla.org/en-US/firefox/addon/103988).
@@ -252,70 +255,16 @@ module Sass::Tree
 
     private
 
-    def resolve_parent_refs(super_rules)
-      if super_rules.nil?
-        return @parsed_rules.map do |rule|
-          if rule.include?(:parent)
-            raise Sass::SyntaxError.new("Base-level rules cannot contain the parent-selector-referencing character '#{PARENT}'.")
-          end
-
-          rule.join
-        end
-      end
-
-      new_rules = []
-      super_rules.each do |super_rule|
-        @parsed_rules.each do |rule|
-          new_rules << []
-
-          # An initial newline of the child rule
-          # should be moved to the beginning of the entire rule
-          rule.first.slice!(0) if nl = (rule.first.is_a?(String) && rule.first[0] == ?\n)
-          rule = [nl ? "\n" : "", :parent, " ", *rule] unless rule.include?(:parent)
-
-          new_rules.last << rule.map do |segment|
-            next segment unless segment == :parent
-            super_rule
-          end.join
-        end
-      end
-      new_rules
-    end
-
-    def parse_selector(text)
-      scanner = StringScanner.new(text)
-      rules = [[]]
-
-      while scanner.rest?
-        rules.last << scanner.scan(/[^",&]*/)
-        case scanner.scan(/./)
-        when '&'; rules.last << :parent
-        when ','
-          scanner.scan(/\s*/)
-          if scanner.rest?
-            rules << []
-            rules.last << "\n" if scanner.matched.include?("\n")
-          end
-        when '"'
-          rules.last << '"' << scanner.scan(/([^"\\]|\\.)*/)
-          # We don't want to enforce that strings are closed,
-          # but we do want to consume quotes or trailing backslashes.
-          rules.last << scanner.scan(/./) if scanner.rest?
-        end
-      end
-
-      rules.map! do |l|
-        Haml::Util.merge_adjacent_strings(l).reject {|r| r.is_a?(String) && r.empty?}
-      end
-
-      rules
-    end
-
     def debug_info_rule
       node = DirectiveNode.new("@media -sass-debug-info")
       debug_info.map {|k, v| [k.to_s, v.to_s]}.sort.each do |k, v|
         rule = RuleNode.new([""])
-        rule.resolved_rules = [[k.to_s.gsub(/[^\w-]/, "\\\\\\0")]]
+        rule.resolved_rules = Sass::Selector::CommaSequence.new(
+          [Sass::Selector::Sequence.new(
+              [Sass::Selector::SimpleSequence.new(
+                  [Sass::Selector::Element.new(k.to_s.gsub(/[^\w-]/, "\\\\\\0"), nil)])
+              ])
+          ])
         prop = PropNode.new([""], "", :new)
         prop.resolved_name = "font-family"
         prop.resolved_value = Sass::SCSS::RX.escape_ident(v.to_s)

data/lib/sass/tree/variable_node.rb

@@ -16,6 +16,7 @@ module Sass
 
       protected
 
+      # @see Node#to_src
       def to_src(tabs, opts, fmt)
         "#{'  ' * tabs}$#{dasherize(@name, opts)}: #{@expr.to_sass(opts)}#{' !default' if @guarded}#{semi fmt}\n"
       end

data/lib/sass/tree/warn_node.rb

@@ -12,6 +12,7 @@ module Sass
 
       protected
 
+      # @see Node#to_src
       def to_src(tabs, opts, fmt)
         "#{'  ' * tabs}@warn #{@expr.to_sass(opts)}#{semi fmt}\n"
       end

data/lib/sass/tree/while_node.rb

@@ -13,6 +13,7 @@ module Sass::Tree
 
     protected
 
+    # @see Node#to_src
     def to_src(tabs, opts, fmt)
       "#{'  ' * tabs}@while #{@expr.to_sass(opts)}" + children_to_src(tabs, opts, fmt)
     end

data/lib/sass.rb

@@ -16,6 +16,7 @@ module Sass
 
   # A string representing the version of Sass.
   # A more fine-grained representation is available from {Haml::Version#version Sass.version}.
+  # @api public
   VERSION = version[:string] unless defined?(Sass::VERSION)
 end
 

data/test/haml/engine_test.rb

@@ -1348,17 +1348,199 @@ SASS
       render("%a{:a => 'b',\n:b => 'c'}(c='d'\nd='e') bar"))
   end
 
+  # Ruby Multiline
+
+  def test_silent_ruby_multiline
+    assert_equal(<<HTML, render(<<HAML))
+bar, baz, bang
+<p>foo</p>
+HTML
+- foo = ["bar",
+         "baz",
+         "bang"]
+= foo.join(", ")
+%p foo
+HAML
+  end
+
+  def test_loud_ruby_multiline
+    assert_equal(<<HTML, render(<<HAML))
+bar, baz, bang
+<p>foo</p>
+<p>bar</p>
+HTML
+= ["bar",
+   "baz",
+   "bang"].join(", ")
+%p foo
+%p bar
+HAML
+  end
+
+  def test_escaped_loud_ruby_multiline
+    assert_equal(<<HTML, render(<<HAML))
+bar&lt;, baz, bang
+<p>foo</p>
+<p>bar</p>
+HTML
+&= ["bar<",
+    "baz",
+    "bang"].join(", ")
+%p foo
+%p bar
+HAML
+  end
+
+  def test_unescaped_loud_ruby_multiline
+    assert_equal(<<HTML, render(<<HAML, :escape_html => true))
+bar<, baz, bang
+<p>foo</p>
+<p>bar</p>
+HTML
+!= ["bar<",
+    "baz",
+    "bang"].join(", ")
+%p foo
+%p bar
+HAML
+  end
+
+  def test_flattened_loud_ruby_multiline
+    assert_equal(<<HTML, render(<<HAML))
+<pre>bar&#x000A;baz&#x000A;bang</pre>
+<p>foo</p>
+<p>bar</p>
+HTML
+~ "<pre>" + ["bar",
+             "baz",
+             "bang"].join("\\n") + "</pre>"
+%p foo
+%p bar
+HAML
+  end
+
+  def test_loud_ruby_multiline_with_block
+    assert_equal(<<HTML, render(<<HAML))
+farfazfang
+<p>foo</p>
+<p>bar</p>
+HTML
+= ["bar",
+   "baz",
+   "bang"].map do |str|
+  - str.gsub("ba",
+             "fa")
+%p foo
+%p bar
+HAML
+  end
+
+  def test_silent_ruby_multiline_with_block
+    assert_equal(<<HTML, render(<<HAML))
+far
+faz
+fang
+<p>foo</p>
+<p>bar</p>
+HTML
+- ["bar",
+   "baz",
+   "bang"].map do |str|
+  = str.gsub("ba",
+             "fa")
+%p foo
+%p bar
+HAML
+  end
+
+  def test_ruby_multiline_in_tag
+    assert_equal(<<HTML, render(<<HAML))
+<p>foo, bar, baz</p>
+<p>foo</p>
+<p>bar</p>
+HTML
+%p= ["foo",
+     "bar",
+     "baz"].join(", ")
+%p foo
+%p bar
+HAML
+  end
+
+  def test_escaped_ruby_multiline_in_tag
+    assert_equal(<<HTML, render(<<HAML))
+<p>foo&lt;, bar, baz</p>
+<p>foo</p>
+<p>bar</p>
+HTML
+%p&= ["foo<",
+      "bar",
+      "baz"].join(", ")
+%p foo
+%p bar
+HAML
+  end
+
+  def test_unescaped_ruby_multiline_in_tag
+    assert_equal(<<HTML, render(<<HAML, :escape_html => true))
+<p>foo<, bar, baz</p>
+<p>foo</p>
+<p>bar</p>
+HTML
+%p!= ["foo<",
+      "bar",
+      "baz"].join(", ")
+%p foo
+%p bar
+HAML
+  end
+
+  def test_ruby_multiline_with_normal_multiline
+    assert_equal(<<HTML, render(<<HAML))
+foobarbar, baz, bang
+<p>foo</p>
+<p>bar</p>
+HTML
+= "foo" + |
+  "bar" + |
+  ["bar", |
+   "baz",
+   "bang"].join(", ")
+%p foo
+%p bar
+HAML
+  end
+
+  def test_ruby_multiline_after_filter
+    assert_equal(<<HTML, render(<<HAML))
+foo
+bar
+bar, baz, bang
+<p>foo</p>
+<p>bar</p>
+HTML
+:plain
+  foo
+  bar
+= ["bar",
+   "baz",
+   "bang"].join(", ")
+%p foo
+%p bar
+HAML
+  end
+
   # Encodings
 
   def test_utf_8_bom
-    assert_equal <<CSS, render(<<SCSS)
+    assert_equal <<HTML, render(<<HAML)
 <div class='foo'>
   <p>baz</p>
 </div>
-CSS
+HTML
 \xEF\xBB\xBF.foo
   %p baz
-SCSS
+HAML
   end
 
   unless Haml::Util.ruby1_8?

data/test/haml/helper_test.rb

@@ -15,7 +15,18 @@ module Haml::Helpers
 end
 
 class HelperTest < Test::Unit::TestCase
-  Post = Struct.new('Post', :body)
+  Post = Struct.new('Post', :body, :error_field, :errors)
+  class PostErrors
+    def on(name)
+      return unless name == 'error_field'
+      ["Really bad error"]
+    end
+    alias_method :full_messages, :on
+
+    def [](name)
+      on(name) || []
+    end
+  end
   
   def setup
     @base = ActionView::Base.new
@@ -26,7 +37,7 @@ class HelperTest < Test::Unit::TestCase
       @base.controller.response = ActionController::Response.new
     end
 
-    @base.instance_variable_set('@post', Post.new("Foo bar\nbaz"))
+    @base.instance_variable_set('@post', Post.new("Foo bar\nbaz", nil, PostErrors.new))
   end
 
   def render(text, options = {})
@@ -153,6 +164,18 @@ HTML
 HAML
   end
 
+  def test_content_tag_error_wrapping
+    def @base.protect_against_forgery?; false; end
+    assert_equal(<<HTML, render(<<HAML, :action_view))
+<form action="" method="post">
+  <div class="fieldWithErrors"><label for="post_error_field">Error field</label></div>
+</form>
+HTML
+#{rails_block_helper_char} form_for #{form_for_calling_convention('post')}, :url => '' do |f|
+  = f.label 'error_field'
+HAML
+  end
+
   def test_haml_tag_name_attribute_with_id
     assert_equal("<p id='some_id'></p>\n", render("- haml_tag 'p#some_id'"))
   end

data/test/haml/template_test.rb

@@ -288,7 +288,7 @@ END
   <input id="article_body" name="article[body]" size="30" type="text" value="World" />
 </form>
 HTML
-- form_for :article, @article, :url => '' do |f|
+- form_for #{form_for_calling_convention(:article)}, :url => '' do |f|
   Title:
   = f.text_field :title
   Body:
@@ -387,7 +387,7 @@ HAML
   <input id="article_body" name="article[body]" size="30" type="text" value="World" />
 </form>
 HTML
-#{rails_block_helper_char} form_for :article, @article, :url => '' do |f|
+#{rails_block_helper_char} form_for #{form_for_calling_convention(:article)}, :url => '' do |f|
   Title:
   = f.text_field :title
   Body:

data/test/haml/templates/helpers.haml

@@ -62,6 +62,19 @@ click
         <input id="article_body" name="article[body]" size="30" type="text" value="World" />
       </form>
     </div>
+- elsif Haml::Util.ap_geq_3_beta_3?
+  %p
+    = form_tag ''
+  %div
+    = form_tag '' do
+      %div= submit_tag 'save'
+      - @foo = 'value one'
+      = test_partial 'partial'
+    = form_for @article, :as => :article, :url => '', :html => {:class => nil, :id => nil} do |f|
+      Title:
+      = f.text_field :title
+      Body:
+      = f.text_field :body
 - elsif Haml::Util.ap_geq_3?
   %p
     = form_tag ''