haml-edge 2.3.93 → 2.3.94

data/lib/sass/script/lexer.rb

@@ -8,16 +8,16 @@ module Sass
     class Lexer
       # A struct containing information about an individual token.
       #
-      # `type`: [{Symbol}]
+      # `type`: \[{Symbol}\]
       # : The type of token.
       #
-      # `value`: [{Object}]
+      # `value`: \[{Object}\]
       # : The Ruby object corresponding to the value of the token.
       #
-      # `line`: [{Fixnum}]
+      # `line`: \[{Fixnum}\]
       # : The line of the source file on which the token appears.
       #
-      # `offset`: [{Fixnum}]
+      # `offset`: \[{Fixnum}\]
       # : The number of bytes into the line the SassScript token appeared.
       Token = Struct.new(:type, :value, :line, :offset)
 
@@ -55,7 +55,7 @@ module Sass
         :variable => /!([\w-]+)/,
         :ident => /(\\.|[^\s\\+*\/%(),=!])+/,
         :number => /(-)?(?:(\d*\.\d+)|(\d+))([a-zA-Z%]+)?/,
-        :color => /\##{"([0-9a-fA-F]{1,2})" * 3}|(#{Color::HTML4_COLORS.keys.join("|")})(?!\()/,
+        :color => /\##{"([0-9a-fA-F]{1,2})" * 3}|(#{Color::HTML4_COLORS.keys.join("|")})(?![^\s+*\/%),=!])/,
         :bool => /(true|false)\b/,
         :op => %r{(#{Regexp.union(*OP_NAMES.map{|s| Regexp.new(Regexp.escape(s) + (s =~ /\w$/ ? '(?:\b|$)' : ''))})})}
       }

data/lib/sass/tree/directive_node.rb

@@ -46,9 +46,9 @@ module Sass::Tree
               if was_prop
                 result[-1] = "\n"
               end
-              rendered = child.to_s(tabs + 1)
-              rendered.lstrip! if first
-              result << rendered
+              rendered = child.to_s(tabs + 1).dup
+              rendered = rendered.lstrip if first
+              result << rendered.rstrip + "\n"
             end
             was_prop = child.is_a?(PropNode)
             first = false

data/lib/sass/tree/import_node.rb

@@ -14,24 +14,35 @@ module Sass
 
       protected
 
-      # Computes the CSS for the imported file.
-      #
-      # @param args [Array] Ignored
-      def _to_s(*args)
-        @to_s ||= (style == :compressed ? super.strip : super)
+      # @see Node#_cssize
+      def _cssize(*args)
+        super.children
       rescue Sass::SyntaxError => e
         e.modify_backtrace(:filename => children.first.filename)
         e.add_backtrace(:filename => @filename, :line => @line)
         raise e
       end
 
-      # Parses the imported file
-      # and runs the dynamic Sass for it.
+      # Returns a static DirectiveNode if this is importing a CSS file,
+      # or parses and includes the imported Sass file.
       #
       # @param environment [Sass::Environment] The lexical environment containing
       #   variable and mixin values
-      def perform!(environment)
-        return unless full_filename = import
+      def _perform(environment)
+        full_filename = import
+        return DirectiveNode.new("@import url(#{full_filename})") if full_filename =~ /\.css$/
+
+        node = dup
+        node.perform!(environment, full_filename)
+        node
+      end
+
+      # Parses the imported file and runs the dynamic Sass for it.
+      #
+      # @param environment [Sass::Environment] The lexical environment containing
+      #   variable and mixin values
+      # @param full_filename [String] The full path to the Sass file to import
+      def perform!(environment, full_filename)
         root = Sass::Files.tree_for(full_filename, @options)
         @template = root.template
         self.children = root.children
@@ -51,18 +62,9 @@ module Sass
       end
 
       def import
-        begin
-          full_filename = Sass::Files.find_file_to_import(@imported_filename, import_paths)
-        rescue Exception => e
-          raise SyntaxError.new(e.message, :line => self.line, :filename => @filename)
-        end
-
-        if full_filename =~ /\.css$/
-          @to_s = "@import url(#{full_filename});"
-          return false
-        end
-
-        return full_filename
+        Sass::Files.find_file_to_import(@imported_filename, import_paths)
+      rescue Exception => e
+        raise SyntaxError.new(e.message, :line => self.line, :filename => @filename)
       end
     end
   end

data/lib/sass/tree/mixin_node.rb

@@ -1,7 +1,9 @@
 require 'sass/tree/node'
 
 module Sass::Tree
-  # A dynamic node representing a mixin include.
+  # A static node representing a mixin include.
+  # When in a static tree, the sole purpose is to wrap exceptions
+  # to add the mixin to the backtrace.
   #
   # @see Sass::Tree
   class MixinNode < Node
@@ -13,17 +15,30 @@ module Sass::Tree
       super()
     end
 
+    # @see Node#cssize
+    def cssize(parent = nil)
+      _cssize(parent) # Pass on the parent even if it's not a MixinNode
+    end
+
     protected
 
+    # @see Node#_cssize
+    def _cssize(parent)
+      children.map {|c| c.cssize(parent)}.flatten
+    rescue Sass::SyntaxError => e
+      e.modify_backtrace(:mixin => @name, :line => line)
+      e.add_backtrace(:filename => filename, :line => line)
+      raise e
+    end
+
     # Runs the mixin.
     #
     # @param environment [Sass::Environment] The lexical environment containing
     #   variable and mixin values
-    # @return [Array<Tree::Node>] The resulting static nodes
     # @raise [Sass::SyntaxError] if there is no mixin with the given name
     # @raise [Sass::SyntaxError] if an incorrect number of arguments was passed
     # @see Sass::Tree
-    def _perform(environment)
+    def perform!(environment)
       raise Sass::SyntaxError.new("Undefined mixin '#{@name}'.") unless mixin = environment.mixin(@name)
 
       raise Sass::SyntaxError.new(<<END.gsub("\n", "")) if mixin.args.size < @args.size
@@ -42,7 +57,12 @@ END
         raise Sass::SyntaxError.new("Mixin #{@name} is missing parameter #{var.inspect}.") unless env.var(var.name)
         env
       end
-      mixin.tree.map {|c| c.perform(environment)}.flatten
+
+      self.children = mixin.tree.map {|c| c.perform(environment)}.flatten
+    rescue Sass::SyntaxError => e
+      e.modify_backtrace(:mixin => @name, :line => @line)
+      e.add_backtrace(:line => @line)
+      raise e
     end
   end
 end

data/lib/sass/tree/node.rb

@@ -1,19 +1,28 @@
 module Sass
   # A namespace for nodes in the Sass parse tree.
   #
-  # The Sass parse tree has two states.
-  # When it's first parsed, it has nodes for mixin definitions
-  # and for loops and so forth,
+  # The Sass parse tree has three states: dynamic, static Sass, and static CSS.
+  #
+  # When it's first parsed, a Sass document is in the dynamic state.
+  # It has nodes for mixin definitions and `@for` loops and so forth,
   # in addition to nodes for CSS rules and properties.
+  # Nodes that only appear in this state are called **dynamic nodes**.
   #
-  # However, {Tree::Node#perform} returns a different sort of tree.
-  # This tree maps more closely to the resulting CSS document
-  # than it does to the original Sass document.
-  # It still has nodes for CSS rules and properties,
+  # {Tree::Node#perform} returns a static Sass tree, which is different.
+  # It still has nodes for CSS rules and properties
   # but it doesn't have any dynamic-generation-related nodes.
+  # The nodes in this state are in the same structure as the Sass document:
+  # rules and properties are nested beneath one another.
+  # Nodes that can be in this state or in the dynamic state
+  # are called **static nodes**.
+  #
+  # {Tree::Node#cssize} then returns a static CSS tree.
+  # This is like a static Sass tree,
+  # but the structure exactly mirrors that of the generated CSS.
+  # Rules and properties can't be nested beneath one another in this state.
   #
-  # Nodes that only appear in the pre-perform state are called **dynamic nodes**;
-  # those that appear in both states are called **static nodes**.
+  # Finally, {Tree::Node#to_s} can be called on a static CSS tree
+  # to get the actual CSS code as a string.
   module Tree
     # The abstract superclass of all parse-tree nodes.
     class Node
@@ -99,7 +108,7 @@ module Sass
       # @see #perform
       # @see #to_s
       def render
-        perform(Environment.new).to_s
+        perform(Environment.new).cssize.to_s
       end
 
       # True if \{#to\_s} will return `nil`;
@@ -116,15 +125,15 @@ module Sass
         @options[:style]
       end
 
-      # Computes the CSS corresponding to this Sass tree.
+      # Computes the CSS corresponding to this static CSS tree.
       #
+      # \{#to_s} shouldn't be overridden directly; instead, override \{#\_to\_s}.
       # Only static-node subclasses need to implement \{#to\_s}.
       #
       # This may return `nil`, but it will only do so if \{#invisible?} is true.
       #
       # @param args [Array] Passed on to \{#\_to\_s}
       # @return [String, nil] The resulting CSS
-      # @raise [Sass::SyntaxError] if some element of the tree is invalid
       # @see Sass::Tree
       def to_s(*args)
         _to_s(*args)
@@ -133,15 +142,31 @@ module Sass
         raise e
       end
 
-      # Runs the dynamic Sass code:
+      # Converts a static Sass tree (e.g. the output of \{#perform})
+      # into a static CSS tree.
+      #
+      # \{#cssize} shouldn't be overridden directly;
+      # instead, override \{#\_cssize} or \{#cssize!}.
+      #
+      # @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
+      # @return [Tree::Node] The resulting tree of static nodes
+      # @raise [Sass::SyntaxError] if some element of the tree is invalid
+      # @see Sass::Tree
+      def cssize(parent = nil)
+        _cssize((parent if parent.class == self.class))
+      rescue Sass::SyntaxError => e
+        e.modify_backtrace(:filename => filename, :line => line)
+        raise e
+      end
+
+      # Converts a dynamic tree into a static Sass tree.
+      # That is, runs the dynamic Sass code:
       # mixins, variables, control directives, and so forth.
       # This doesn't modify this node or any of its children.
       #
       # \{#perform} shouldn't be overridden directly;
-      # if you want to return a new node (or list of nodes),
-      # override \{#\_perform};
-      # if you want to destructively modify this node,
-      # override \{#perform!}.
+      # instead, override \{#\_perform} or \{#perform!}.
       #
       # @param environment [Sass::Environment] The lexical environment containing
       #   variable and mixin values
@@ -159,15 +184,46 @@ module Sass
 
       # Computes the CSS corresponding to this particular Sass node.
       #
+      # This method should never raise {Sass::SyntaxError}s.
+      # Such errors will not be properly annotated with Sass backtrace information.
+      # All error conditions should be checked in earlier transformations,
+      # such as \{#cssize} and \{#perform}.
+      #
       # @param args [Array] ignored
       # @return [String, nil] The resulting CSS
-      # @raise [Sass::SyntaxError] if some element of the tree is invalid
       # @see #to_s
       # @see Sass::Tree
       def _to_s
         raise NotImplementedError.new("All static-node subclasses of Sass::Tree::Node must override #_to_s or #to_s.")
       end
 
+      # Converts this static Sass node into a static CSS node,
+      # returning the new node.
+      # This doesn't modify this node or any of its children.
+      #
+      # @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
+      # @return [Tree::Node, Array<Tree::Node>] The resulting static CSS nodes
+      # @raise [Sass::SyntaxError] if some element of the tree is invalid
+      # @see #cssize
+      # @see Sass::Tree
+      def _cssize(parent)
+        node = dup
+        node.cssize!(parent)
+        node
+      end
+
+      # Destructively converts this static Sass node into a static CSS node.
+      # This *does* modify this node,
+      # but will be run non-destructively by \{#\_cssize\}.
+      #
+      # @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 #cssize
+      def cssize!(parent)
+        self.children = children.map {|c| c.cssize(self)}.flatten
+      end
+
       # Runs any dynamic Sass code in this particular node.
       # This doesn't modify this node or any of its children.
       #

data/lib/sass/tree/prop_node.rb

@@ -18,13 +18,13 @@ module Sass::Tree
     # relative to a normal property.
     # This is only greater than 0 in the case that:
     #
-    # * This node is in a static tree
+    # * This node is in a CSS tree
     # * The style is :nested
     # * This is a child property of another property
     # * The parent property has a value, and thus will be rendered
     #
     # @return [Fixnum]
-    attr_accessor :indentation
+    attr_accessor :tabs
 
     # @param name [String] See \{#name}
     # @param value [String] See \{#value}
@@ -33,7 +33,7 @@ module Sass::Tree
     def initialize(name, value, prop_syntax)
       @name = name
       @value = value
-      @indentation = 0
+      @tabs = 0
       @prop_syntax = prop_syntax
       super()
     end
@@ -63,34 +63,37 @@ module Sass::Tree
     #
     # @param tabs [Fixnum] The level of indentation for the CSS
     # @return [String] The resulting CSS
-    # @raise [Sass::SyntaxError] if the property uses invalid syntax
     def _to_s(tabs)
-      if @options[:property_syntax] == :old && @prop_syntax == :new
-        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?
-        raise Sass::SyntaxError.new("Invalid property: #{declaration.dump} (no value)." +
-          pseudo_class_selector_message)
-      end
-
-      to_return = '  ' * (tabs - 1 + indentation) + name + ":" +
+      to_return = '  ' * (tabs - 1 + self.tabs) + name + ":" +
         (style == :compressed ? '' : ' ') + value + (style == :compressed ? "" : ";")
     end
 
-    # Returns this node's fully-resolved child properties, and/or this node.
+    # Converts nested properties into flat properties.
     #
-    # @param environment [Sass::Environment] The lexical environment containing
-    #   variable and mixin values
-    def _perform(environment)
+    # @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)
       node = super
       result = node.children.dup
-      result.unshift(node) if !node.value.empty? || node.children.empty?
+      if !node.value.empty? || node.children.empty?
+        node.send(:check!)
+        result.unshift(node)
+      end
       result
     end
 
+    # Updates the name and indentation of this node based on the parent name
+    # and nesting level.
+    #
+    # @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
+      super
+    end
+
     # Runs any SassScript that may be embedded in the property,
     # and invludes the parent property, if any.
     #
@@ -100,12 +103,6 @@ module Sass::Tree
       @name = interpolate(@name, environment)
       @value = @value.is_a?(String) ? interpolate(@value, environment) : @value.perform(environment).to_s
       super
-      # Once we've called super, the child nodes have been dup'ed
-      # so we can destructively modify them
-      children.select {|c| c.is_a?(PropNode)}.each do |c|
-        c.name = "#{name}-#{c.name}"
-        c.indentation += 1 if style == :nested && !@value.empty?
-      end
     end
 
     # Returns an error message if the given child node is invalid,
@@ -122,6 +119,19 @@ module Sass::Tree
 
     private
 
+    def check!
+      if @options[:property_syntax] == :old && @prop_syntax == :new
+        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?
+        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
     end

data/lib/sass/tree/root_node.rb

@@ -13,7 +13,7 @@ module Sass
         @template = template
       end
 
-      # @see \{Node#to\_s}
+      # @see Node#to_s
       def to_s(*args)
         super
       rescue Sass::SyntaxError => e
@@ -21,7 +21,7 @@ module Sass
         raise e
       end
 
-      # @see \{Node#perform}
+      # @see Node#perform
       def perform(environment)
         environment.options = @options if environment.options.nil? || environment.options.empty?
         super
@@ -30,23 +30,38 @@ module Sass
         raise e
       end
 
+      # @see Node#cssize
+      def cssize(*args)
+        super
+      rescue Sass::SyntaxError => e
+        e.sass_template = @template
+        raise e
+      end
+
       protected
 
+      # 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
       # @return [String] The resulting CSS
-      # @raise [Sass::SyntaxError] if some element of the tree is invalid
       # @see Sass::Tree
       def _to_s(*args)
         result = String.new
         children.each do |child|
-          if child.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
-
           next if child.invisible?
           child_str = child.to_s(1)
           result << child_str + (style == :compressed ? '' : "\n")