sass 3.1.0.alpha.2

data/lib/sass/tree/extend_node.rb

@@ -0,0 +1,65 @@
+require 'sass/tree/node'
+
+module Sass::Tree
+  # A static node reprenting an `@extend` directive.
+  #
+  # @see Sass::Tree
+  class ExtendNode < Node
+    # @param selector [Array<String, Sass::Script::Node>]
+    #   The CSS selector to extend,
+    #   interspersed with {Sass::Script::Node}s
+    #   representing `#{}`-interpolation.
+    def initialize(selector)
+      @selector = selector
+      super()
+    end
+
+    # Registers this extension in the `extends` subset map.
+    #
+    # @param extends [Sass::Util::SubsetMap{Selector::Simple => Selector::Sequence}]
+    #   The extensions defined for this tree
+    # @param parent [RuleNode] The parent node of this node
+    # @see Node#cssize
+    def cssize(extends, parent)
+      @resolved_selector.members.each do |seq|
+        if seq.members.size > 1
+          raise Sass::SyntaxError.new("Can't extend #{seq.to_a.join}: can't extend nested selectors")
+        end
+
+        sseq = seq.members.first
+        if !sseq.is_a?(Sass::Selector::SimpleSequence)
+          raise Sass::SyntaxError.new("Can't extend #{seq.to_a.join}: invalid selector")
+        end
+
+        sel = sseq.members
+        parent.resolved_rules.members.each do |seq|
+          if !seq.members.last.is_a?(Sass::Selector::SimpleSequence)
+            raise Sass::SyntaxError.new("#{seq} can't extend: invalid selector")
+          end
+
+          extends[sel] = seq
+        end
+      end
+
+      []
+    end
+
+    protected
+
+    # @see Node#to_src
+    def to_src(tabs, opts, fmt)
+      "#{'  ' * tabs}@extend #{selector_to_src(@selector, tabs, opts, fmt).lstrip}#{semi fmt}\n"
+    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)
+      @resolved_selector = Sass::SCSS::CssParser.new(run_interp(@selector, environment), self.line).
+        parse_selector(self.filename)
+      super
+    end
+  end
+end

data/lib/sass/tree/for_node.rb

@@ -0,0 +1,67 @@
+require 'sass/tree/node'
+
+module Sass::Tree
+  # A dynamic node representing a Sass `@for` loop.
+  #
+  # @see Sass::Tree
+  class ForNode < Node
+    # @param var [String] The name of the loop variable
+    # @param from [Script::Node] The parse tree for the initial expression
+    # @param to [Script::Node] The parse tree for the final expression
+    # @param exclusive [Boolean] Whether to include `to` in the loop
+    #   or stop just before
+    def initialize(var, from, to, exclusive)
+      @var = var
+      @from = from
+      @to = to
+      @exclusive = exclusive
+      super()
+    end
+
+    protected
+
+    # @see Node#to_src
+    def to_src(tabs, opts, fmt)
+      to = @exclusive ? "to" : "through"
+      "#{'  ' * tabs}@for $#{dasherize(@var, opts)} from #{@from.to_sass(opts)} #{to} #{@to.to_sass(opts)}" +
+        children_to_src(tabs, opts, fmt)
+    end
+
+    # Runs the child nodes once for each time through the loop,
+    # varying the variable each time.
+    #
+    # @param environment [Sass::Environment] The lexical environment containing
+    #   variable and mixin values
+    # @return [Array<Tree::Node>] The resulting static nodes
+    # @see Sass::Tree
+    def _perform(environment)
+      from = @from.perform(environment)
+      to = @to.perform(environment)
+      from.assert_int!
+      to.assert_int!
+
+      to = to.coerce(from.numerator_units, from.denominator_units)
+      range = Range.new(from.to_i, to.to_i, @exclusive)
+
+      children = []
+      environment = Sass::Environment.new(environment)
+      range.each do |i|
+        environment.set_local_var(@var, Sass::Script::Number.new(i, from.numerator_units, from.denominator_units))
+        children += perform_children(environment)
+      end
+      children
+    end
+
+    # Returns an error message if the given child node is invalid,
+    # and false otherwise.
+    #
+    # {ExtendNode}s are valid within {ForNode}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
+  end
+end

data/lib/sass/tree/if_node.rb

@@ -0,0 +1,81 @@
+require 'sass/tree/node'
+
+module Sass::Tree
+  # A dynamic node representing a Sass `@if` statement.
+  #
+  # {IfNode}s are a little odd, in that they also represent `@else` and `@else if`s.
+  # This is done as a linked list:
+  # each {IfNode} has a link (\{#else}) to the next {IfNode}.
+  #
+  # @see Sass::Tree
+  class IfNode < Node
+    # The next {IfNode} in the if-else list, or `nil`.
+    #
+    # @return [IfNode]
+    attr_accessor :else
+
+    # @param expr [Script::Expr] The conditional expression.
+    #   If this is nil, this is an `@else` node, not an `@else if`
+    def initialize(expr)
+      @expr = expr
+      @last_else = self
+      super()
+    end
+
+    # Append an `@else` node to the end of the list.
+    #
+    # @param node [IfNode] The `@else` node to append
+    def add_else(node)
+      @last_else.else = node
+      @last_else = node
+    end
+
+    # @see Node#options=
+    def options=(options)
+      super
+      self.else.options = options if self.else
+    end
+
+    protected
+
+    # @see Node#to_src
+    def to_src(tabs, opts, fmt, is_else = false)
+      name =
+        if !is_else; "if"
+        elsif @expr; "else if"
+        else; "else"
+        end
+      str = "#{'  ' * tabs}@#{name}"
+      str << " #{@expr.to_sass(opts)}" if @expr
+      str << children_to_src(tabs, opts, fmt)
+      str << @else.send(:to_src, tabs, opts, fmt, true) if @else
+      str
+    end
+
+    # Runs the child nodes if the conditional expression is true;
+    # otherwise, tries the \{#else} nodes.
+    #
+    # @param environment [Sass::Environment] The lexical environment containing
+    #   variable and mixin values
+    # @return [Array<Tree::Node>] The resulting static nodes
+    # @see Sass::Tree
+    def _perform(environment)
+      environment = Sass::Environment.new(environment)
+      return perform_children(environment) if @expr.nil? || @expr.perform(environment).to_bool
+      return @else.perform(environment) if @else
+      []
+    end
+
+    # Returns an error message if the given child node is invalid,
+    # and false otherwise.
+    #
+    # {ExtendNode}s are valid within {IfNode}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
+  end
+end

data/lib/sass/tree/import_node.rb

@@ -0,0 +1,124 @@
+module Sass
+  module Tree
+    # A static node that wraps the {Sass::Tree} for an `@import`ed file.
+    # It doesn't have a functional purpose other than to add the `@import`ed file
+    # to the backtrace if an error occurs.
+    class ImportNode < RootNode
+      # The name of the imported file as it appears in the Sass document.
+      #
+      # @return [String]
+      attr_reader :imported_filename
+
+      # @param imported_filename [String] The name of the imported file
+      def initialize(imported_filename)
+        @imported_filename = imported_filename
+        super(nil)
+      end
+
+      def invisible?; to_s.empty?; end
+
+      # Returns the imported file.
+      #
+      # @return [Sass::Engine]
+      # @raise [Sass::SyntaxError] If no file could be found to import.
+      def imported_file
+        @imported_file ||= import
+      end
+
+      # @see Node#to_sass
+      def to_sass(tabs = 0, opts = {})
+        "#{'  ' * tabs}@import #{@imported_filename}\n"
+      end
+
+      # @see Node#to_scss
+      def to_scss(tabs = 0, opts = {})
+        "#{'  ' * tabs}@import \"#{@imported_filename}\";\n"
+      end
+
+      # @see Node#cssize
+      def cssize(*args)
+        super.first
+      end
+
+      # Returns whether or not this import should emit a CSS @import declaration
+      #
+      # @return [Boolean] Whether or not this is a simple CSS @import declaration.
+      def css_import?
+        if @imported_filename =~ /\.css$/
+          @imported_filename
+        elsif imported_file.is_a?(String) && imported_file =~ /\.css$/
+          imported_file
+        end
+      end
+
+      protected
+
+      # @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
+
+      # 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)
+        if path = css_import?
+          return DirectiveNode.new("@import url(#{path})")
+        end
+        super
+      end
+
+      # Parses the imported file and runs the dynamic Sass for it.
+      #
+      # @param environment [Sass::Environment] The lexical environment containing
+      #   variable and mixin values
+      def perform!(environment)
+        environment.push_frame(:filename => @filename, :line => @line)
+        # TODO: re-enable caching
+        root = imported_file.to_tree
+        self.children = root.children
+        self.children = perform_children(environment)
+      rescue Sass::SyntaxError => e
+        e.modify_backtrace(:filename => imported_file.options[:filename])
+        e.add_backtrace(:filename => @filename, :line => @line)
+        raise e
+      ensure
+        environment.pop_frame
+      end
+
+      private
+
+      def import
+        paths = @options[:load_paths]
+
+        if @options[:importer]
+          f = @options[:importer].find_relative(
+            @imported_filename, @options[:filename], @options.dup)
+          return f if f
+        end
+
+        paths.each do |p|
+          if f = p.find(@imported_filename, @options.dup)
+            return f
+          end
+        end
+
+        message = "File to import not found or unreadable: #{@imported_filename}.\n"
+        if paths.size == 1
+          message << "Load path: #{paths.first}"
+        else
+          message << "Load paths:\n  " << paths.join("\n  ")
+        end
+        raise SyntaxError.new(message)
+      rescue SyntaxError => e
+        raise SyntaxError.new(e.message, :line => self.line, :filename => @filename)
+      end
+    end
+  end
+end

data/lib/sass/tree/mixin_def_node.rb

@@ -0,0 +1,60 @@
+module Sass
+  module Tree
+    # A dynamic node representing a mixin definition.
+    #
+    # @see Sass::Tree
+    class MixinDefNode < Node
+      # @param name [String] The mixin name
+      # @param args [Array<(Script::Node, Script::Node)>] The arguments for the mixin.
+      #   Each element is a tuple containing the variable for argument
+      #   and the parse tree for the default value of the argument
+      def initialize(name, args)
+        @name = name
+        @args = args
+        super()
+      end
+
+      protected
+
+      # @see Node#to_src
+      def to_src(tabs, opts, fmt)
+        args =
+          if @args.empty?
+            ""
+          else
+            '(' + @args.map do |v, d|
+              if d
+                "#{v.to_sass(opts)}: #{d.to_sass(opts)}"
+              else
+                v.to_sass(opts)
+              end
+            end.join(", ") + ')'
+          end
+              
+        "#{'  ' * tabs}#{fmt == :sass ? '=' : '@mixin '}#{dasherize(@name, opts)}#{args}" +
+          children_to_src(tabs, opts, fmt)
+      end
+
+      # Loads the mixin into the environment.
+      #
+      # @param environment [Sass::Environment] The lexical environment containing
+      #   variable and mixin values
+      def _perform(environment)
+        environment.set_mixin(@name, Sass::Mixin.new(@name, @args, environment, children))
+        []
+      end
+
+      # Returns an error message if the given child node is invalid,
+      # and false otherwise.
+      #
+      # {ExtendNode}s are valid within {MixinDefNode}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
+    end
+  end
+end

data/lib/sass/tree/mixin_node.rb

@@ -0,0 +1,123 @@
+require 'sass/tree/node'
+
+module Sass::Tree
+  # 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
+    # @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)
+      @name = name
+      @args = args
+      super()
+    end
+
+    # @see Node#cssize
+    def cssize(extends, parent = nil)
+      _cssize(extends, parent) # Pass on the parent even if it's not a MixinNode
+    end
+
+    protected
+
+    # Returns an error message if the given child node is invalid,
+    # and false otherwise.
+    #
+    # {ExtendNode}s are valid within {MixinNode}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
+
+    # @see Node#to_src
+    def to_src(tabs, opts, fmt)
+      args = '(' + @args.map {|a| a.to_sass(opts)}.join(", ") + ')' unless @args.empty?
+      "#{'  ' * tabs}#{fmt == :sass ? '+' : '@include '}#{dasherize(@name, opts)}#{args}#{semi fmt}\n"
+    end
+
+    # @see Node#_cssize
+    def _cssize(extends, parent)
+      children.map do |c|
+        parent.check_child! c
+        c.cssize(extends, parent)
+      end.flatten
+    rescue Sass::SyntaxError => e
+      e.modify_backtrace(:mixin => @name, :filename => filename, :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
+    # @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)
+      handle_include_loop!(environment) if environment.mixins_in_use.include?(@name)
+
+      original_env = environment
+      original_env.push_frame(:filename => filename, :line => line)
+      original_env.prepare_frame(:mixin => @name)
+      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
+Mixin #{@name} takes #{mixin.args.size} argument#{'s' if mixin.args.size != 1}
+ but #{@args.size} #{@args.size == 1 ? 'was' : 'were'} passed.
+END
+      environment = mixin.args.zip(@args).
+        inject(Sass::Environment.new(mixin.environment)) do |env, ((var, default), value)|
+        env.set_local_var(var.name,
+          if value
+            value.perform(environment)
+          elsif default
+            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
+      end
+
+      self.children = mixin.tree.map {|c| c.perform(environment)}.flatten
+    rescue Sass::SyntaxError => e
+      if original_env # Don't add backtrace info if this is an @include loop
+        e.modify_backtrace(:mixin => @name, :line => @line)
+        e.add_backtrace(:line => @line)
+      end
+      raise e
+    ensure
+      original_env.pop_frame if original_env
+    end
+
+    private
+
+    def handle_include_loop!(environment)
+      msg = "An @include loop has been found:"
+      mixins = environment.stack.map {|s| s[:mixin]}.compact
+      if mixins.size == 2 && mixins[0] == mixins[1]
+        raise Sass::SyntaxError.new("#{msg} #{@name} includes itself")
+      end
+
+      mixins << @name
+      msg << "\n" << Sass::Util.enum_cons(mixins, 2).map do |m1, m2|
+        "    #{m1} includes #{m2}"
+      end.join("\n")
+      raise Sass::SyntaxError.new(msg)
+    end
+  end
+end