haml-edge 2.3.179 → 2.3.180

data/lib/sass/tree/mixin_def_node.rb

@@ -16,6 +16,24 @@ module Sass
 
       protected
 
+      def to_src(tabs, opts, fmt)
+        args =
+          if @args.empty?
+            ""
+          else
+            '(' + @args.map do |v, d|
+              if d
+                "#{v.to_sass}: #{d.to_sass}"
+              else
+                v.to_sass
+              end
+            end.join(", ") + ')'
+          end
+              
+        "#{'  ' * tabs}#{fmt == :sass ? '=' : '@mixin '}#{@name}#{args}" +
+          children_to_src(tabs, opts, fmt)
+      end
+
       # Loads the mixin into the environment.
       #
       # @param environment [Sass::Environment] The lexical environment containing

data/lib/sass/tree/mixin_node.rb

@@ -7,6 +7,12 @@ module Sass::Tree
   #
   # @see Sass::Tree
   class MixinNode < Node
+    # @see Node#options=
+    def options=(opts)
+      super
+      @args.each {|a| a.context = :equals} if opts[:sass2]
+    end
+
     # @param name [String] The name of the mixin
     # @param args [Array<Script::Node>] The arguments to the mixin
     def initialize(name, args)
@@ -22,6 +28,11 @@ module Sass::Tree
 
     protected
 
+    def to_src(tabs, opts, fmt)
+      args = '(' + @args.map {|a| a.to_sass}.join(", ") + ')' unless @args.empty?
+      "#{'  ' * tabs}#{fmt == :sass ? '+' : '@include '}#{@name}#{args}#{semi fmt}\n"
+    end
+
     # @see Node#_cssize
     def _cssize(parent)
       children.map {|c| c.cssize(parent)}.flatten
@@ -52,7 +63,11 @@ END
           if value
             value.perform(environment)
           elsif default
-            default.perform(env)
+            val = default.perform(env)
+            if default.context == :equals && val.is_a?(Sass::Script::String)
+              val = Sass::Script::String.new(val.value)
+            end
+            val
           end)
         raise Sass::SyntaxError.new("Mixin #{@name} is missing parameter #{var.inspect}.") unless env.var(var.name)
         env

data/lib/sass/tree/node.rb

@@ -26,11 +26,20 @@ module Sass
   module Tree
     # The abstract superclass of all parse-tree nodes.
     class Node
+      include Enumerable
+
       # The child nodes of this node.
       #
       # @return [Array<Tree::Node>]
       attr_accessor :children
 
+      # Whether or not this node has child nodes.
+      # This may be true even when \{#children} is empty,
+      # in which case this node has an empty block (e.g. `{}`).
+      #
+      # @return [Boolean]
+      attr_accessor :has_children
+
       # The line of the document on which this node appeared.
       #
       # @return [Fixnum]
@@ -60,6 +69,12 @@ module Sass
         @options = options
       end
 
+      # @private
+      def children=(children)
+        self.has_children ||= !children.empty?
+        @children = children
+      end
+
       # The name of the document on which this node appeared.
       #
       # @return [String]
@@ -73,21 +88,14 @@ module Sass
       # @raise [Sass::SyntaxError] if `child` is invalid
       # @see #invalid_child?
       def <<(child)
+        return if child.nil?
         if msg = invalid_child?(child)
           raise Sass::SyntaxError.new(msg, :line => child.line)
         end
+        self.has_children = true
         @children << child
       end
 
-      # Return the last child node.
-      #
-      # We need this because {Tree::Node} duck types as an Array for {Sass::Engine}.
-      #
-      # @return [Tree::Node] The last child node
-      def last
-        children.last
-      end
-
       # Compares this node and another object (only other {Tree::Node}s will be equal).
       # This does a structural comparison;
       # if the contents of the nodes and all the child nodes are equivalent,
@@ -180,6 +188,34 @@ module Sass
         raise e
       end
 
+      # Iterates through each node in the tree rooted at this node
+      # in a pre-order walk.
+      #
+      # @yield node
+      # @yieldparam node [Node] a node in the tree
+      def each(&block)
+        yield self
+        children.each {|c| c.each(&block)}
+      end
+
+      # Converts a node to Sass code that will generate it.
+      #
+      # @param tabs [Fixnum] The amount of tabulation to use for the Sass code
+      # @param opts [{Symbol => Object}] An options hash (see {Sass::CSS#initialize})
+      # @return [String] The Sass code corresponding to the node
+      def to_sass(tabs = 0, opts = {})
+        to_src(tabs, opts, :sass)
+      end
+
+      # Converts a node to SCSS code that will generate it.
+      #
+      # @param tabs [Fixnum] The amount of tabulation to use for the SCSS code
+      # @param opts [{Symbol => Object}] An options hash (see {Sass::CSS#initialize})
+      # @return [String] The Sass code corresponding to the node
+      def to_scss(tabs = 0, opts = {})
+        to_src(tabs, opts, :scss)
+      end
+
       protected
 
       # Computes the CSS corresponding to this particular Sass node.
@@ -258,27 +294,21 @@ module Sass
         children.map {|c| c.perform(environment)}.flatten
       end
 
-      # Replaces SassScript in a chunk of text (via `#{}`)
+      # Replaces SassScript in a chunk of text
       # with the resulting value.
       #
-      # @param text [String] The text to interpolate
+      # @param text [Array<String, Sass::Script::Node>] The text to interpolate
       # @param environment [Sass::Environment] The lexical environment containing
       #   variable and mixin values
       # @return [String] The interpolated text
-      def interpolate(text, environment)
-        res = ''
-        rest = Haml::Shared.handle_interpolation text do |scan|
-          escapes = scan[2].size
-          res << scan.matched[0...-2 - escapes]
-          if escapes % 2 == 1
-            res << "\\" * (escapes - 1) << '#{'
-          else
-            res << "\\" * [0, escapes - 1].max
-            res << Script::Parser.new(scan, line, scan.pos - scan.matched_size, filename).
-              parse_interpolated.perform(environment).to_s
-          end
-        end
-        res + rest
+      def run_interp(text, environment)
+        text.map do |r|
+          next r if r.is_a?(String)
+          val = r.perform(environment)
+          # Interpolated strings should never render with quotes
+          next val.value if val.is_a?(Sass::Script::String)
+          val.to_s
+        end.join.strip
       end
 
       # @see Haml::Shared.balance
@@ -292,7 +322,8 @@ module Sass
       # Returns an error message if the given child node is invalid,
       # and false otherwise.
       #
-      # By default, all child nodes are valid.
+      # By default, all child nodes except those only allowed at root level
+      # ({Tree::MixinDefNode}, {Tree::ImportNode}) are valid.
       # This is expected to be overriden by subclasses
       # for which some children are invalid.
       #
@@ -300,7 +331,47 @@ module Sass
       # @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)
-        false
+        case child
+        when Tree::MixinDefNode
+          "Mixins may only be defined at the root of a document."
+        when Tree::ImportNode
+          "Import directives may only be used at the root of a document."
+        end
+      end
+
+      # Converts a node to Sass or SCSS code that will generate it.
+      #
+      # This method is called by the default \{#to\_sass} and \{#to\_scss} methods,
+      # so that the same code can be used for both with minor variations.
+      #
+      # @param tabs [Fixnum] The amount of tabulation to use for the SCSS code
+      # @param opts [{Symbol => Object}] An options hash (see {Sass::CSS#initialize})
+      # @param fmt [Symbol] `:sass` or `:scss`
+      # @return [String] The Sass or SCSS code corresponding to the node
+      def to_src(tabs, opts, fmt)
+        raise NotImplementedError.new("All static-node subclasses of Sass::Tree::Node must override #to_#{fmt}.")
+      end
+
+      # Converts the children of this node to a Sass or SCSS string.
+      # This will return the trailing newline for the previous line,
+      # including brackets if this is SCSS.
+      #
+      # @param tabs [Fixnum] The amount of tabulation to use for the Sass code
+      # @param opts [{Symbol => Object}] An options hash (see {Sass::CSS#initialize})
+      # @param fmt [Symbol] `:sass` or `:scss`
+      # @return [String] The Sass or CSS code corresponding to the children
+      def children_to_src(tabs, opts, fmt)
+        (fmt == :sass ? "\n" : " {\n") +
+          children.map {|c| c.send("to_#{fmt}", tabs + 1, opts)}.join.rstrip +
+          (fmt == :sass ? "\n" : " }\n")
+      end
+
+      # Returns a semicolon if this is SCSS, or an empty string if this is Sass.
+      #
+      # @param fmt [Symbol] `:sass` or `:scss`
+      # @return [String] A semicolon or the empty string
+      def semi(fmt)
+        fmt == :sass ? "" : ";"
       end
     end
   end

data/lib/sass/tree/prop_node.rb

@@ -3,17 +3,33 @@ module Sass::Tree
   #
   # @see Sass::Tree
   class PropNode < Node
-    # The name of the property.
+    # The name of the property,
+    # interspersed with {Sass::Script::Node}s
+    # representing `#{}`-interpolation.
+    # Any adjacent strings will be merged together.
     #
-    # @return [String]
+    # @return [Array<String, Sass::Script::Node>]
     attr_accessor :name
 
-    # The value of the property,
-    # either a plain string or a SassScript parse tree.
+    # The name of the property
+    # after any interpolated SassScript has been resolved.
+    # Only set once \{Tree::Node#perform} has been called.
+    #
+    # @return [String]
+    attr_accessor :resolved_name
+
+    # The value of the property.
     #
-    # @return [String, Script::Node]
+    # @return [Sass::Script::Node]
     attr_accessor :value
 
+    # The value of the property
+    # after any interpolated SassScript has been resolved.
+    # Only set once \{Tree::Node#perform} has been called.
+    #
+    # @return [String]
+    attr_accessor :resolved_value
+
     # How deep this property is indented
     # relative to a normal property.
     # This is only greater than 0 in the case that:
@@ -26,12 +42,13 @@ module Sass::Tree
     # @return [Fixnum]
     attr_accessor :tabs
 
-    # @param name [String] See \{#name}
-    # @param value [String] See \{#value}
+    # @param name [Array<String, Sass::Script::Node>] See \{#name}
+    # @param value [Sass::Script::Node] See \{#value}
     # @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)
-      @name = name
+      @name = Haml::Util.strip_string_array(
+        Haml::Util.merge_adjacent_strings(name))
       @value = value
       @tabs = 0
       @prop_syntax = prop_syntax
@@ -51,21 +68,33 @@ 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 || !value.empty?
+      return "" if @prop_syntax == :new || !resolved_value.empty?
       "\nIf #{declaration.dump} should be a selector, use \"\\#{declaration}\" instead."
     end
 
     protected
 
+    def to_src(tabs, opts, fmt)
+      name = self.name.map {|n| n.is_a?(String) ? n : "\#{#{n.to_sass}}"}.join
+      old = opts[:old] && fmt == :sass
+      initial = old ? ':' : ''
+      mid = old ? '' : ':'
+      res = "#{'  ' * tabs}#{initial}#{name}#{mid} #{self.class.val_to_sass(value)}"
+      return res + "#{semi fmt}\n" if children.empty?
+      res.rstrip + children_to_src(tabs, opts, fmt)
+    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)
-      to_return = '  ' * (tabs - 1 + self.tabs) + name + ":" +
-        (style == :compressed ? '' : ' ') + value + (style == :compressed ? "" : ";")
+      to_return = '  ' * (tabs - 1 + self.tabs) + resolved_name + ":" +
+        (style == :compressed ? '' : ' ') + resolved_value + (style == :compressed ? "" : ";")
     end
 
     # Converts nested properties into flat properties.
@@ -76,7 +105,7 @@ module Sass::Tree
     def _cssize(parent)
       node = super
       result = node.children.dup
-      if !node.value.empty? || node.children.empty?
+      if !node.resolved_value.empty? || node.children.empty?
         node.send(:check!)
         result.unshift(node)
       end
@@ -89,8 +118,8 @@ module Sass::Tree
     # @param parent [PropNode, nil] The parent node of this node,
     #   or nil if the parent isn't a {PropNode}
     def cssize!(parent)
-      self.name = "#{parent.name}-#{name}" if parent
-      self.tabs = parent.tabs + (parent.value.empty? ? 0 : 1) if parent && style == :nested
+      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
 
@@ -100,8 +129,14 @@ module Sass::Tree
     # @param environment [Sass::Environment] The lexical environment containing
     #   variable and mixin values
     def perform!(environment)
-      @name = interpolate(@name, environment)
-      @value = @value.is_a?(String) ? interpolate(@value, environment) : @value.perform(environment).to_s
+      @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
 
@@ -124,16 +159,58 @@ module Sass::Tree
         raise Sass::SyntaxError.new("Illegal property syntax: can't use new syntax when :property_syntax => :old is set.")
       elsif @options[:property_syntax] == :new && @prop_syntax == :old
         raise Sass::SyntaxError.new("Illegal property syntax: can't use old syntax when :property_syntax => :new is set.")
-      elsif value[-1] == ?;
-        raise Sass::SyntaxError.new("Invalid property: #{declaration.dump} (no \";\" required at end-of-line).")
-      elsif value.empty?
+      elsif resolved_value.empty?
         raise Sass::SyntaxError.new("Invalid property: #{declaration.dump} (no value)." +
           pseudo_class_selector_message)
       end
     end
 
     def declaration
-      (@prop_syntax == :new ? "#{name}: #{value}" : ":#{name} #{value}").strip
+      if @prop_syntax == :new
+        "#{resolved_name}: #{resolved_value}"
+      else
+        ":#{resolved_name} #{resolved_value}"
+      end.strip
+    end
+
+    class << self
+      # @private
+      def val_to_sass(value)
+        return value.to_sass unless value.context == :equals
+        val_to_sass_comma(value).to_sass
+      end
+
+      private
+
+      def val_to_sass_comma(node)
+        return node unless node.is_a?(Sass::Script::Operation)
+        return val_to_sass_concat(node) unless node.operator == :comma
+
+        Sass::Script::Operation.new(
+          val_to_sass_concat(node.operand1),
+          val_to_sass_comma(node.operand2),
+          node.operator)
+      end
+
+      def val_to_sass_concat(node)
+        return node unless node.is_a?(Sass::Script::Operation)
+        return val_to_sass_div(node) unless node.operator == :concat
+
+        Sass::Script::Operation.new(
+          val_to_sass_div(node.operand1),
+          val_to_sass_concat(node.operand2),
+          node.operator)
+      end
+
+      def val_to_sass_div(node)
+        unless node.is_a?(Sass::Script::Operation) && node.operator == :div &&
+            node.operand1.is_a?(Sass::Script::Number) &&
+            node.operand2.is_a?(Sass::Script::Number)
+          return node
+        end
+
+        Sass::Script::String.new("(#{node.to_sass})")
+      end
     end
   end
 end

data/lib/sass/tree/root_node.rb

@@ -44,8 +44,37 @@ module Sass
         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
 
+      def to_src(opts, fmt)
+        Haml::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)
+              ""
+            else
+              "\n"
+            end
+        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.
       #
@@ -76,6 +105,14 @@ module Sass
         return "" if result.empty?
         return result + "\n"
       end
+
+      # Returns false, because all nodes are allowed at the root of the document
+      # (properties are detected elsewhere post-mixin-resolution).
+      #
+      # @see Node#invalid_child?
+      def invalid_child?(child)
+        false
+      end
     end
   end
 end