haml 3.1.0 → 3.1.1

data/vendor/sass/lib/sass/tree/prop_node.rb

@@ -13,7 +13,7 @@ module Sass::Tree
 
     # The name of the property
     # after any interpolated SassScript has been resolved.
-    # Only set once \{Tree::Node#perform} has been called.
+    # Only set once \{Tree::Visitors::Perform} has been run.
     #
     # @return [String]
     attr_accessor :resolved_name
@@ -23,9 +23,14 @@ module Sass::Tree
     # @return [Sass::Script::Node]
     attr_accessor :value
 
+    # Whether the property was marked as !important.
+    #
+    # @return [Boolean]
+    attr_accessor :important
+
     # The value of the property
     # after any interpolated SassScript has been resolved.
-    # Only set once \{Tree::Node#perform} has been called.
+    # Only set once \{Tree::Visitors::Perform} has been run.
     #
     # @return [String]
     attr_accessor :resolved_value
@@ -44,14 +49,16 @@ module Sass::Tree
 
     # @param name [Array<String, Sass::Script::Node>] See \{#name}
     # @param value [Sass::Script::Node] See \{#value}
+    # @param important [Boolean] whether this is an !important property
     # @param prop_syntax [Symbol] `:new` if this property uses `a: b`-style syntax,
     #   `:old` if it uses `:a b`-style syntax
-    def initialize(name, value, prop_syntax)
+    def initialize(name, value, important, prop_syntax)
       @name = Sass::Util.strip_string_array(
         Sass::Util.merge_adjacent_strings(name))
       @value = value
       @tabs = 0
       @prop_syntax = prop_syntax
+      @important = important
       super()
     end
 
@@ -74,85 +81,22 @@ module Sass::Tree
       "\nIf #{declaration.dump} should be a selector, use \"\\#{declaration}\" instead."
     end
 
-    protected
-
-    # @see Node#to_src
-    def to_src(tabs, opts, fmt)
-      res = declaration(tabs, opts, fmt)
-      return res + "#{semi fmt}\n" if children.empty?
-      res + children_to_src(tabs, opts, fmt).rstrip + semi(fmt) + "\n"
-    end
-
-    # Computes the CSS for the property.
-    #
-    # @param tabs [Fixnum] The level of indentation for the CSS
-    # @return [String] The resulting CSS
-    def _to_s(tabs)
-      tab_str = '  ' * (tabs - 1 + self.tabs)
-      if style == :compressed
-        "#{tab_str}#{resolved_name}:#{resolved_value}"
-      else
-        "#{tab_str}#{resolved_name}: #{resolved_value};"
-      end
-    end
-
-    # Converts nested properties into flat properties.
+    # Computes the Sass or SCSS code for the variable declaration.
+    # This is like \{#to\_scss} or \{#to\_sass},
+    # except it doesn't print any child properties or a trailing semicolon.
     #
-    # @param extends [Sass::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(extends, parent)
-      node = super
-      result = node.children.dup
-      if !node.resolved_value.empty? || node.children.empty?
-        node.send(:check!)
-        result.unshift(node)
+    # @param opts [{Symbol => Object}] The options hash for the tree.
+    # @param fmt [Symbol] `:scss` or `:sass`.
+    def declaration(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
-      result
-    end
 
-    # Updates the name and indentation of this node based on the parent name
-    # and nesting level.
-    #
-    # @param extends [Sass::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!(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
-    end
-
-    # Runs any SassScript that may be embedded in the property,
-    # and invludes the parent property, if any.
-    #
-    # @param environment [Sass::Environment] The lexical environment containing
-    #   variable and mixin values
-    def perform!(environment)
-      @resolved_name = run_interp(@name, environment)
-      val = @value.perform(environment)
-      @resolved_value =
-        if @value.context == :equals && val.is_a?(Sass::Script::String)
-          val.value
-        else
-          val.to_s
-        end
-      super
-    end
-
-    # Returns an error message if the given child node is invalid,
-    # and false otherwise.
-    #
-    # {PropNode} only allows other {PropNode}s and {CommentNode}s as children.
-    # @param child [Tree::Node] A potential child node
-    # @return [String] An error message if the child is invalid, or nil otherwise
-    def invalid_child?(child)
-      if !child.is_a?(PropNode) && !child.is_a?(CommentNode)
-        "Illegal nesting: Only properties may be nested beneath properties."
-      end
+      old = opts[:old] && fmt == :sass
+      initial = old ? ':' : ''
+      mid = old ? '' : ':'
+      "#{initial}#{name}#{mid} #{self.class.val_to_sass(value, opts)}#{' !important' if important}".rstrip
     end
 
     private
@@ -167,18 +111,6 @@ module Sass::Tree
       end
     end
 
-    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
       # @private
       def val_to_sass(value, opts)
@@ -211,7 +143,7 @@ module Sass::Tree
         unless node.is_a?(Sass::Script::Operation) && node.operator == :div &&
             node.operand1.is_a?(Sass::Script::Number) &&
             node.operand2.is_a?(Sass::Script::Number) &&
-            (node.context == :equals || !node.operand1.original || !node.operand2.original)
+            (!node.operand1.original || !node.operand2.original)
           return node
         end
 

data/vendor/sass/lib/sass/tree/return_node.rb

@@ -0,0 +1,18 @@
+module Sass
+  module Tree
+    # A dynamic node representing returning from a function.
+    #
+    # @see Sass::Tree
+    class ReturnNode < Node
+      # The expression to return.
+      # @type [Script::Node]
+      attr_reader :expr
+
+      # @param expr [Script::Node] The expression to return
+      def initialize(expr)
+        @expr = expr
+        super()
+      end
+    end
+  end
+end

data/vendor/sass/lib/sass/tree/root_node.rb

@@ -13,145 +13,16 @@ module Sass
         @template = template
       end
 
-      # @see Node#to_s
-      def to_s(*args)
-        super
-      rescue Sass::SyntaxError => e
-        e.sass_template ||= @template
-        raise e
-      end
-
       # Runs the dynamic Sass code *and* computes the CSS for the tree.
-      #
-      # @see #perform
       # @see #to_s
       def render
-        result, extends = perform(Environment.new).cssize
+        Visitors::CheckNesting.visit(self)
+        result = Visitors::Perform.visit(self)
+        Visitors::CheckNesting.visit(result) # Check again to validate mixins
+        result, extends = Visitors::Cssize.visit(result)
         result = result.do_extend(extends) unless extends.empty?
         result.to_s
       end
-
-      # @see Node#perform
-      def perform(environment)
-        environment.options = @options if environment.options.nil? || environment.options.empty?
-        super
-      rescue Sass::SyntaxError => e
-        e.sass_template ||= @template
-        raise e
-      end
-
-      # Like {Node#cssize}, except that this method
-      # will create its own `extends` map if necessary,
-      # and it returns that map along with the cssized tree.
-      #
-      # @return [(Tree::Node, Sass::Util::SubsetMap)] The resulting tree of static nodes
-      #   *and* the extensions defined for this tree
-      def cssize(extends = Sass::Util::SubsetMap.new, parent = nil)
-        return super(extends, parent), extends
-      rescue Sass::SyntaxError => e
-        e.sass_template ||= @template
-        raise e
-      end
-
-      # @see \{Node#perform!}
-      def perform!(environment)
-        environment.options = @options if environment.options.nil? || environment.options.empty?
-        super
-      end
-
-      # Converts a node to Sass code that will generate it.
-      #
-      # @param opts [{Symbol => Object}] An options hash (see {Sass::CSS#initialize})
-      # @return [String] The Sass code corresponding to the node
-      def to_sass(opts = {})
-        to_src(opts, :sass)
-      end
-
-      # Converts a node to SCSS code that will generate it.
-      #
-      # @param opts [{Symbol => Object}] An options hash (see {Sass::CSS#initialize})
-      # @return [String] The SCSS code corresponding to the node
-      def to_scss(opts = {})
-        to_src(opts, :scss)
-      end
-
-      protected
-
-      # @see Node#to_src
-      def to_src(opts, fmt)
-        Sass::Util.enum_cons(children + [nil], 2).map do |child, nxt|
-          child.send("to_#{fmt}", 0, opts) +
-            if nxt &&
-                (child.is_a?(CommentNode) && child.line + child.value.count("\n") + 1 == nxt.line) ||
-                (child.is_a?(ImportNode) && nxt.is_a?(ImportNode) && child.line + 1 == nxt.line) ||
-                (child.is_a?(VariableNode) && nxt.is_a?(VariableNode) && child.line + 1 == nxt.line)
-              ""
-            else
-              "\n"
-            end
-        end.join.rstrip + "\n"
-      end
-
-      # Computes the CSS corresponding to this Sass tree.
-      #
-      # @param args [Array] ignored
-      # @return [String] The resulting CSS
-      # @see Sass::Tree
-      def _to_s(*args)
-        result = String.new
-        children.each do |child|
-          next if child.invisible?
-          child_str = child.to_s(1)
-          result << child_str + (style == :compressed ? '' : "\n")
-        end
-        result.rstrip!
-        return "" if result.empty?
-        result << "\n"
-        unless Sass::Util.ruby1_8? || result.ascii_only?
-          if children.first.is_a?(CharsetNode)
-            begin
-              encoding = children.first.name
-              # Default to big-endian encoding, because we have to decide somehow
-              encoding << 'BE' if encoding =~ /\Autf-(16|32)\Z/i
-              result = result.encode(Encoding.find(encoding))
-            rescue EncodingError
-            end
-          end
-
-          result = "@charset \"#{result.encoding.name}\";#{
-            style == :compressed ? '' : "\n"
-          }".encode(result.encoding) + result
-        end
-        result
-      end
-
-      # In Ruby 1.8, ensures that there's only one @charset directive
-      # and that it's at the top of the document.
-      #
-      # @see Node#cssize
-      def cssize!(extends, parent)
-        super
-
-        # In Ruby 1.9 we can make all @charset nodes invisible
-        # and infer the final @charset from the encoding of the final string.
-        if Sass::Util.ruby1_8? && parent.nil?
-          charset = self.children.find {|c| c.is_a?(CharsetNode)}
-          self.children.reject! {|c| c.is_a?(CharsetNode)}
-          self.children.unshift charset if charset
-        end
-      end
-
-      # 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)
-        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
 end

data/vendor/sass/lib/sass/tree/rule_node.rb

@@ -27,7 +27,7 @@ module Sass::Tree
 
     # The CSS selector for this rule,
     # without any unresolved interpolation or parent references.
-    # It's only set once {Tree::Node#cssize} has been called.
+    # It's only set once {Tree::Visitors::Cssize} has been run.
     #
     # @return [Selector::CommaSequence]
     attr_accessor :resolved_rules
@@ -56,9 +56,22 @@ module Sass::Tree
       merged = Sass::Util.merge_adjacent_strings(rule)
       @rule = Sass::Util.strip_string_array(merged)
       @tabs = 0
+      try_to_parse_non_interpolated_rules
       super()
     end
 
+    # If we've precached the parsed selector, set the line on it, too.
+    def line=(line)
+      @parsed_rules.line = line if @parsed_rules
+      super
+    end
+
+    # If we've precached the parsed selector, set the filename on it, too.
+    def filename=(filename)
+      @parsed_rules.filename = filename if @parsed_rules
+      super
+    end
+
     # Compares the contents of two rules.
     #
     # @param other [Object] The object to compare with
@@ -74,6 +87,7 @@ module Sass::Tree
     def add_rules(node)
       @rule = Sass::Util.strip_string_array(
         Sass::Util.merge_adjacent_strings(@rule + ["\n"] + node.rule))
+      try_to_parse_non_interpolated_rules
     end
 
     # @return [Boolean] Whether or not this rule is continued on the next line
@@ -82,26 +96,6 @@ module Sass::Tree
       last.is_a?(String) && last[-1] == ?,
     end
 
-    # @see Node#to_sass
-    def to_sass(tabs, opts = {})
-      name = selector_to_sass(rule, opts)
-      name = "\\" + name if name[0] == ?:
-      name.gsub(/^/, '  ' * tabs) + children_to_src(tabs, opts, :sass)
-    end
-
-    # @see Node#to_scss
-    def to_scss(tabs, opts = {})
-      name = selector_to_scss(rule, tabs, opts)
-      res = name + children_to_src(tabs, opts, :scss)
-
-      if children.last.is_a?(CommentNode) && children.last.silent
-        res.slice!(-3..-1)
-        res << "\n" << ('  ' * tabs) << "}\n"
-      end
-
-      res
-    end
-
     # Extends this Rule's selector with the given `extends`.
     #
     # @see Node#do_extend
@@ -111,132 +105,6 @@ module Sass::Tree
       node
     end
 
-    protected
-
-    # Computes the CSS for the rule.
-    #
-    # @param tabs [Fixnum] The level of indentation for the CSS
-    # @return [String] The resulting CSS
-    def _to_s(tabs)
-      output_style = style
-      tabs = tabs + self.tabs
-
-      rule_separator = output_style == :compressed ? ',' : ', '
-      line_separator =
-        case output_style
-          when :nested, :expanded; "\n"
-          when :compressed; ""
-          else; " "
-        end
-      rule_indent = '  ' * (tabs - 1)
-      per_rule_indent, total_indent = [:nested, :expanded].include?(output_style) ? [rule_indent, ''] : ['', rule_indent]
-
-      total_rule = total_indent + resolved_rules.members.
-        map {|seq| seq.to_a.join.gsub(/([^,])\n/m, style == :compressed ? '\1 ' : "\\1\n")}.
-        join(rule_separator).split("\n").map do |line|
-        per_rule_indent + line.strip
-      end.join(line_separator)
-
-      to_return = ''
-      old_spaces = '  ' * (tabs - 1)
-      spaces = '  ' * tabs
-      if output_style != :compressed
-        if @options[:debug_info]
-          to_return << debug_info_rule.to_s(tabs) << "\n"
-        elsif @options[:line_comments]
-          to_return << "#{old_spaces}/* line #{line}"
-
-          if filename
-            relative_filename = if @options[:css_filename]
-              begin
-                Pathname.new(filename).relative_path_from(
-                  Pathname.new(File.dirname(@options[:css_filename]))).to_s
-              rescue ArgumentError
-                nil
-              end
-            end
-            relative_filename ||= filename
-            to_return << ", #{relative_filename}"
-          end
-
-          to_return << " */\n"
-        end
-      end
-
-      if output_style == :compact
-        properties = children.map { |a| a.to_s(1) }.join(' ')
-        to_return << "#{total_rule} { #{properties} }#{"\n" if group_end}"
-      elsif output_style == :compressed
-        properties = children.map { |a| a.to_s(1) }.join(';')
-        to_return << "#{total_rule}{#{properties}}"
-      else
-        properties = children.map { |a| a.to_s(tabs + 1) }.join("\n")
-        end_props = (output_style == :expanded ? "\n" + old_spaces : ' ')
-        to_return << "#{total_rule} {\n#{properties}#{end_props}}#{"\n" if group_end}"
-      end
-
-      to_return
-    end
-
-    # 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 = Sass::SCSS::StaticParser.new(run_interp(@rule, environment), self.line).
-        parse_selector(self.filename)
-      super
-    end
-
-    # Converts nested rules into a flat list of rules.
-    #
-    # @param extends [Sass::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(extends, parent)
-      node = super
-      rules = node.children.select {|c| c.is_a?(RuleNode) || c.is_a?(MediaNode)}
-      props = node.children.reject {|c| c.is_a?(RuleNode) || c.is_a?(MediaNode) || c.invisible?}
-
-      unless props.empty?
-        node.children = props
-        rules.each {|r| r.tabs += 1} if style == :nested
-        rules.unshift(node)
-      end
-
-      rules.last.group_end = true unless parent || rules.empty?
-
-      rules
-    end
-
-    # Resolves parent references and nested selectors,
-    # and updates the indentation based on the parent's indentation.
-    #
-    # @param extends [Sass::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!(extends, parent)
-      # It's possible for resolved_rules to be set if we've duplicated this node during @media bubbling
-      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 node.
-    # @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).
@@ -249,24 +117,13 @@ module Sass::Tree
 
     private
 
-    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 = 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)
-        rule << prop
-        node << rule
+    def try_to_parse_non_interpolated_rules
+      if @rule.all? {|t| t.kind_of?(String)}
+        # We don't use real filename/line info because we don't have it yet.
+        # When we get it, we'll set it on the parsed rules if possible.
+        parser = Sass::SCSS::StaticParser.new(@rule.join.strip, 1)
+        @parsed_rules = parser.parse_selector('') rescue nil
       end
-      node.options = @options.merge(:debug_info => false, :line_comments => false, :style => :compressed)
-      node
     end
   end
 end