sass 3.1.0.alpha.50 → 3.1.0.alpha.51

data/EDGE_GEM_VERSION

@@ -1 +1 @@
-3.1.0.alpha.50
+3.1.0.alpha.51

data/VERSION

@@ -1 +1 @@
-3.1.0.alpha.50
+3.1.0.alpha.51

data/lib/sass.rb

@@ -67,9 +67,6 @@ end
 
 require 'sass/util'
 
-dir = Sass::Util.scope("vendor/fssm/lib")
-$LOAD_PATH.unshift dir unless $LOAD_PATH.include?(dir)
-
 require 'sass/engine'
 require 'sass/plugin' if defined?(Merb::Plugins)
 require 'sass/railtie'

data/lib/sass/engine.rb

@@ -12,6 +12,8 @@ require 'sass/tree/media_node'
 require 'sass/tree/variable_node'
 require 'sass/tree/mixin_def_node'
 require 'sass/tree/mixin_node'
+require 'sass/tree/function_node'
+require 'sass/tree/return_node'
 require 'sass/tree/extend_node'
 require 'sass/tree/if_node'
 require 'sass/tree/while_node'
@@ -26,6 +28,7 @@ require 'sass/tree/visitors/perform'
 require 'sass/tree/visitors/cssize'
 require 'sass/tree/visitors/convert'
 require 'sass/tree/visitors/to_css'
+require 'sass/tree/visitors/check_nesting'
 require 'sass/selector'
 require 'sass/environment'
 require 'sass/script'
@@ -36,24 +39,24 @@ require 'sass/shared'
 
 module Sass
 
-  # A Sass mixin.
+  # A Sass mixin or function.
   #
   # `name`: `String`
-  # : The name of the mixin.
+  # : The name of the mixin/function.
   #
   # `args`: `Array<(String, Script::Node)>`
-  # : The arguments for the mixin.
+  # : The arguments for the mixin/function.
   #   Each element is a tuple containing the name of the argument
   #   and the parse tree for the default value of the argument.
   #
   # `environment`: {Sass::Environment}
-  # : The environment in which the mixin was defined.
-  #   This is captured so that the mixin can have access
+  # : The environment in which the mixin/function was defined.
+  #   This is captured so that the mixin/function can have access
   #   to local variables defined in its scope.
   #
-  # `tree`: {Sass::Tree::Node}
-  # : The parse tree for the mixin.
-  Mixin = Struct.new(:name, :args, :environment, :tree)
+  # `tree`: `Array<Tree::Node>`
+  # : The parse tree for the mixin/function.
+  Callable = Struct.new(:name, :args, :environment, :tree)
 
   # This class handles the parsing and compilation of the Sass template.
   # Example usage:
@@ -635,6 +638,8 @@ WARNING
         parse_mixin_definition(line)
       elsif directive == "include"
         parse_mixin_include(line, root)
+      elsif directive == "function"
+        parse_function(line, root)
       elsif directive == "for"
         parse_for(line, root, value)
       elsif directive == "each"
@@ -665,6 +670,12 @@ WARNING
           :line => @line + 1) unless line.children.empty?
         offset = line.offset + line.text.index(value).to_i
         Tree::WarnNode.new(parse_script(value, :offset => offset))
+      elsif directive == "return"
+        raise SyntaxError.new("Invalid @return: expected expression.") unless value
+        raise SyntaxError.new("Illegal nesting: Nothing may be nested beneath return directives.",
+          :line => @line + 1) unless line.children.empty?
+        offset = line.offset + line.text.index(value).to_i
+        Tree::ReturnNode.new(parse_script(value, :offset => offset))
       elsif directive == "charset"
         name = value && value[/\A(["'])(.*)\1\Z/, 2] #"
         raise SyntaxError.new("Invalid charset directive '@charset': expected string.") unless name
@@ -787,7 +798,6 @@ WARNING
       offset = line.offset + line.text.size - arg_string.size
       args = Script::Parser.new(arg_string.strip, @line, offset, @options).
         parse_mixin_definition_arglist
-      default_arg_found = false
       Tree::MixinDefNode.new(name, args)
     end
 
@@ -804,6 +814,17 @@ WARNING
       Tree::MixinNode.new(name, args, keywords)
     end
 
+    FUNCTION_RE = /^@function\s*(#{Sass::SCSS::RX::IDENT})(.*)$/
+    def parse_function(line, root)
+      name, arg_string = line.text.scan(FUNCTION_RE).first
+      raise SyntaxError.new("Invalid function definition \"#{line.text}\".") if name.nil?
+
+      offset = line.offset + line.text.size - arg_string.size
+      args = Script::Parser.new(arg_string.strip, @line, offset, @options).
+        parse_function_definition_arglist
+      Tree::FunctionNode.new(name, args)
+    end
+
     def parse_script(script, options = {})
       line = options[:line] || @line
       offset = options[:offset] || 0

data/lib/sass/environment.rb

@@ -2,7 +2,7 @@ require 'set'
 
 module Sass
   # The lexical environment for SassScript.
-  # This keeps track of variable and mixin definitions.
+  # This keeps track of variable, mixin, and function definitions.
   #
   # A new environment is created for each level of Sass nesting.
   # This allows variables to be lexically scoped.
@@ -146,7 +146,10 @@ RUBY
     # Script::Literal
     inherited_hash :var
     # mixin
-    # Engine::Mixin
+    # Sass::Callable
     inherited_hash :mixin
+    # function
+    # Sass::Callable
+    inherited_hash :function
   end
 end

data/lib/sass/plugin/compiler.rb

@@ -213,13 +213,19 @@ module Sass::Plugin
       begin
         require 'fssm'
       rescue LoadError => e
-        e.message << "\n" <<
-          if File.exists?(scope(".git"))
-            'Run "git submodule update --init" to get the recommended version.'
-          else
-            'Run "gem install fssm" to get it.'
-          end
-        raise e
+        dir = Sass::Util.scope("vendor/fssm/lib")
+        if $LOAD_PATH.include?(dir)
+          e.message << "\n" <<
+            if File.exists?(scope(".git"))
+              'Run "git submodule update --init" to get the recommended version.'
+            else
+              'Run "gem install fssm" to get it.'
+            end
+          raise e
+        else
+          $LOAD_PATH.unshift dir
+          retry
+        end
       end
 
       unless individual_files.empty? && FSSM::Backends::Default.name == "FSSM::Backends::FSEvents"

data/lib/sass/script/funcall.rb

@@ -76,6 +76,10 @@ module Sass
       def _perform(environment)
         args = @args.map {|a| a.perform(environment)}
         keywords = Sass::Util.map_hash(@keywords) {|k, v| [k, v.perform(environment)]}
+        if fn = environment.function(@name)
+          return perform_sass_fn(fn, args, keywords)
+        end
+
         ruby_name = @name.tr('-', '_')
         args = construct_ruby_args(ruby_name, args, keywords)
 
@@ -89,6 +93,8 @@ module Sass
         raise Sass::SyntaxError.new("#{e.message} for `#{name}'")
       end
 
+      private
+
       def construct_ruby_args(name, args, keywords)
         return args if keywords.empty?
         unless signature = Functions.signature(name.to_sym, args.size, keywords.size)
@@ -113,6 +119,30 @@ module Sass
 
         args
       end
+
+      def perform_sass_fn(function, args, keywords)
+        # TODO: merge with mixin arg evaluation?
+        keywords.each do |name, value|
+          # TODO: Make this fast
+          unless function.args.find {|(var, default)| var.underscored_name == name}
+            raise Sass::SyntaxError.new("Function #{@name} doesn't have an argument named $#{name}")
+          end
+        end
+
+        environment = function.args.zip(args).
+          inject(Sass::Environment.new(function.environment)) do |env, ((var, default), value)|
+          env.set_local_var(var.name,
+            value || keywords[var.underscored_name] || (default && default.perform(env)))
+          raise Sass::SyntaxError.new("Function #{@name} is missing parameter #{var.inspect}.") unless env.var(var.name)
+          env
+        end
+
+        val = catch :_sass_return do
+          function.tree.each {|c| Sass::Tree::Visitors::Perform.visit(c, environment)}
+          raise Sass::SyntaxError.new("Function #{@name} finished without @return")
+        end
+        val
+      end
     end
   end
 end

data/lib/sass/script/parser.rb

@@ -112,6 +112,24 @@ module Sass
         raise e
       end
 
+      # Parses the argument list for a function definition.
+      #
+      # @return [Array<Script::Node>] The root nodes of the arguments.
+      # @raise [Sass::SyntaxError] if the argument list isn't valid SassScript
+      def parse_function_definition_arglist
+        args = defn_arglist!(true)
+        assert_done
+
+        args.each do |k, v|
+          k.options = @options
+          v.options = @options if v
+        end
+        args
+      rescue Sass::SyntaxError => e
+        e.modify_backtrace :line => @lexer.line, :filename => @options[:filename]
+        raise e
+      end
+
       # Parses a SassScript expression.
       #
       # @overload parse(str, line, offset, filename = nil)
@@ -283,10 +301,16 @@ RUBY
         node(Script::Funcall.new(tok.value, args, keywords))
       end
 
-      def defn_arglist!(must_have_default)
-        return [] unless try_tok(:lparen)
+      def defn_arglist!(must_have_parens)
+        if must_have_parens
+          assert_tok(:lparen)
+        else
+          return [] unless try_tok(:lparen)
+        end
         return [] if try_tok(:rparen)
+
         res = []
+        must_have_default = false
         loop do
           line = @lexer.line
           offset = @lexer.offset + 1

data/lib/sass/scss/parser.rb

@@ -98,8 +98,8 @@ module Sass
         node << comment
       end
 
-      DIRECTIVES = Set[:mixin, :include, :debug, :warn, :for, :each, :while, :if,
-        :else, :extend, :import, :media, :charset]
+      DIRECTIVES = Set[:mixin, :include, :function, :return, :debug, :warn, :for,
+        :each, :while, :if, :else, :extend, :import, :media, :charset]
 
       def directive
         return unless tok(/@/)
@@ -144,6 +144,17 @@ module Sass
         node(Sass::Tree::MixinNode.new(name, args, keywords))
       end
 
+      def function_directive
+        name = tok! IDENT
+        args = sass_script(:parse_function_definition_arglist)
+        ss
+        block(node(Sass::Tree::FunctionNode.new(name, args)), :function)
+      end
+
+      def return_directive
+        node(Sass::Tree::ReturnNode.new(sass_script(:parse)))
+      end
+
       def debug_directive
         node(Sass::Tree::DebugNode.new(sass_script(:parse)))
       end
@@ -365,6 +376,7 @@ module Sass
       end
 
       def block_child(context)
+        return variable || directive if context == :function
         return variable || directive || ruleset if context == :stylesheet
         variable || directive || declaration_or_ruleset
       end

data/lib/sass/tree/each_node.rb

@@ -20,19 +20,5 @@ module Sass::Tree
       @list = list
       super()
     end
-
-    protected
-
-    # Returns an error message if the given child node is invalid,
-    # and false otherwise.
-    #
-    # {ExtendNode}s are valid within {EachNode}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/function_node.rb

@@ -0,0 +1,27 @@
+module Sass
+  module Tree
+    # A dynamic node representing a function definition.
+    #
+    # @see Sass::Tree
+    class FunctionNode < Node
+      # The name of the function.
+      # @return [String]
+      attr_reader :name
+
+      # The arguments to the function. Each element is a tuple
+      # containing the variable for argument and the parse tree for
+      # the default value of the argument
+      #
+      # @return [Array<Script::Node>]
+      attr_reader :args
+
+      # @param name [String] The function name
+      # @param args [Array<(Script::Node, Script::Node)>] The arguments for the function.
+      def initialize(name, args)
+        @name = name
+        @args = args
+        super()
+      end
+    end
+  end
+end

data/lib/sass/tree/node.rb

@@ -86,29 +86,16 @@ module Sass
       #
       # @param child [Tree::Node, Array<Tree::Node>] The child node or nodes
       # @raise [Sass::SyntaxError] if `child` is invalid
-      # @see #invalid_child?
       def <<(child)
         return if child.nil?
         if child.is_a?(Array)
           child.each {|c| self << c}
         else
-          check_child! child
           self.has_children = true
           @children << child
         end
       end
 
-      # Raises an error if the given child node is invalid.
-      #
-      # @param child [Tree::Node] The child node
-      # @raise [Sass::SyntaxError] if `child` is invalid
-      # @see #invalid_child?
-      def check_child!(child)
-        if msg = invalid_child?(child)
-          raise Sass::SyntaxError.new(msg, :line => child.line)
-        end
-      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,
@@ -227,26 +214,6 @@ module Sass
         return res if res
         raise Sass::SyntaxError.new("Unbalanced brackets.", :line => line)
       end
-
-      # Returns an error message if the given child node is invalid,
-      # and false otherwise.
-      #
-      # By default, all child nodes except those only allowed under specific nodes
-      # ({Tree::MixinDefNode}, {Tree::ImportNode}, {Tree::ExtendNode}) are valid.
-      # This is expected to be overriden by subclasses
-      # for which some children are invalid.
-      #
-      # @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)
-        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
     end
   end
 end

data/lib/sass/tree/prop_node.rb

@@ -92,18 +92,6 @@ module Sass::Tree
       "#{initial}#{name}#{mid} #{self.class.val_to_sass(value, opts)}".rstrip
     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
-    end
-
     private
 
     def check!

data/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/lib/sass/tree/root_node.rb

@@ -16,28 +16,13 @@ module Sass
       # Runs the dynamic Sass code *and* computes the CSS for the tree.
       # @see #to_s
       def render
-        result, extends = Visitors::Cssize.visit(Visitors::Perform.visit(self))
+        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
-
-      # 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)
-        case child
-        when Tree::ExtendNode
-          "Extend directives may only be used within rules."
-        when Tree::PropNode
-          "Properties aren't allowed at the root of a document." +
-            child.pseudo_class_selector_message
-        else
-          return
-        end
-      end
     end
   end
 end

data/lib/sass/tree/visitors/base.rb

@@ -32,7 +32,7 @@ module Sass::Tree::Visitors
     # @param node [Tree::Node] The node to visit.
     # @return [Object] The return value of the `visit_*` method for this node.
     def visit(node)
-      method = "visit_#{node.class.name.gsub(/.*::(.*?)Node$/, '\\1').downcase}"
+      method = "visit_#{node_name node}"
       if self.respond_to?(method)
         self.send(method, node) {visit_children(node)}
       else
@@ -53,6 +53,14 @@ module Sass::Tree::Visitors
       parent.children.map {|c| visit(c)}
     end
 
+    # Returns the name of a node as used in the `visit_*` method.
+    #
+    # @param [Tree::Node] node The node.
+    # @return [String] The name.
+    def node_name(node)
+      node.class.name.gsub(/.*::(.*?)Node$/, '\\1').downcase
+    end
+
     # `yield`s, then runs the visitor on the `@else` clause if the node has one.
     # This exists to ensure that the contents of the `@else` clause get visited.
     def visit_if(node)

data/lib/sass/tree/visitors/check_nesting.rb

@@ -0,0 +1,101 @@
+# A visitor for checking that all nodes are properly nested.
+class Sass::Tree::Visitors::CheckNesting < Sass::Tree::Visitors::Base
+  protected
+
+  def visit(node)
+    if error = @parent && (
+        try_send("invalid_#{node_name @parent}_child?", @parent, node) ||
+        try_send("invalid_#{node_name node}_parent?", @parent, node))
+      raise Sass::SyntaxError.new(error)
+    end
+    super
+  rescue Sass::SyntaxError => e
+    e.modify_backtrace(:filename => node.filename, :line => node.line)
+    raise e
+  end
+
+  def visit_children(parent)
+    old_parent = @parent
+    @parent = parent unless is_any_of?(parent, 
+      Sass::Tree::EachNode, Sass::Tree::ForNode, Sass::Tree::IfNode,
+      Sass::Tree::ImportNode, Sass::Tree::MixinNode, Sass::Tree::WhileNode)
+    super
+  ensure
+    @parent = old_parent
+  end
+
+  def visit_root(node)
+    yield
+  rescue Sass::SyntaxError => e
+    e.sass_template ||= node.template
+    raise e
+  end
+
+  def visit_import(node)
+    yield
+  rescue Sass::SyntaxError => e
+    e.modify_backtrace(:filename => node.children.first.filename)
+    e.add_backtrace(:filename => node.filename, :line => node.line)
+    raise e
+  end
+
+  def invalid_charset_parent?(parent, child)
+    "@charset may only be used at the root of a document." unless parent.is_a?(Sass::Tree::RootNode)
+  end
+
+  def invalid_extend_parent?(parent, child)
+    unless is_any_of?(parent, Sass::Tree::RuleNode, Sass::Tree::MixinDefNode)
+      "Extend directives may only be used within rules."
+    end
+  end
+
+  def invalid_function_parent?(parent, child)
+    "Functions may only be defined at the root of a document." unless parent.is_a?(Sass::Tree::RootNode)
+  end
+
+  def invalid_function_child?(parent, child)
+    unless is_any_of?(child,
+        Sass::Tree::CommentNode, Sass::Tree::DebugNode, Sass::Tree::EachNode,
+        Sass::Tree::ForNode, Sass::Tree::IfNode, Sass::Tree::ReturnNode,
+        Sass::Tree::VariableNode, Sass::Tree::WarnNode, Sass::Tree::WhileNode)
+      "Functions can only contain variable declarations and control directives."
+    end
+  end
+
+  def invalid_import_parent?(parent, child)
+    "Import directives may only be used at the root of a document." unless parent.is_a?(Sass::Tree::RootNode)
+  end
+
+  def invalid_mixindef_parent?(parent, child)
+    "Mixins may only be defined at the root of a document." unless parent.is_a?(Sass::Tree::RootNode)
+  end
+
+  def invalid_prop_child?(parent, child)
+    unless is_any_of?(child, Sass::Tree::CommentNode, Sass::Tree::PropNode)
+      "Illegal nesting: Only properties may be nested beneath properties."
+    end
+  end
+
+  def invalid_prop_parent?(parent, child)
+    unless is_any_of?(parent,
+        Sass::Tree::RuleNode, Sass::Tree::PropNode,
+        Sass::Tree::MixinDefNode, Sass::Tree::DirectiveNode)
+      "Properties are only allowed within rules, directives, or other properties." + child.pseudo_class_selector_message
+    end
+  end
+
+  def invalid_return_parent?(parent, child)
+    "@return may only be used within a function." unless parent.is_a?(Sass::Tree::FunctionNode)
+  end
+
+  private
+
+  def is_any_of?(val, *classes)
+    classes.any? {|c| val.is_a?(c)}
+  end
+
+  def try_send(method, *args, &block)
+    return unless respond_to?(method)
+    send(method, *args, &block)
+  end
+end

data/lib/sass/tree/visitors/convert.rb

@@ -110,6 +110,14 @@ class Sass::Tree::Visitors::Convert < Sass::Tree::Visitors::Base
       "#{node.exclusive ? "to" : "through"} #{node.to.to_sass(@options)}#{yield}"
   end
 
+  def visit_function(node)
+    args = node.args.map do |v, d|
+      d ? "#{v.to_sass(@options)}: #{d.to_sass(@options)}" : v.to_sass(@options)
+    end.join(", ")
+
+    "#{tab_str}@function #{dasherize(node.name)}(#{args})#{yield}"
+  end
+
   def visit_if(node)
     name =
       if !@is_else; "if"
@@ -167,6 +175,10 @@ class Sass::Tree::Visitors::Convert < Sass::Tree::Visitors::Base
     res + yield.rstrip + semi + "\n"
   end
 
+  def visit_return(node)
+    "#{tab_str}@return #{node.expr.to_sass(@options)}#{semi}\n"
+  end
+
   def visit_rule(node)
     if @format == :sass
       name = selector_to_sass(node.rule)

data/lib/sass/tree/visitors/cssize.rb

@@ -123,11 +123,8 @@ class Sass::Tree::Visitors::Cssize < Sass::Tree::Visitors::Base
 
   # Asserts that all the mixin's children are valid in their new location.
   def visit_mixin(node)
-    node.children.map do |c|
-      parent.check_child! c
-      # Don't use #visit_children to avoid adding the mixin node to the list of parents.
-      visit(c)
-    end.flatten
+    # Don't use #visit_children to avoid adding the mixin node to the list of parents.
+    node.children.map {|c| visit(c)}.flatten
   rescue Sass::SyntaxError => e
     e.modify_backtrace(:mixin => node.name, :filename => node.filename, :line => node.line)
     e.add_backtrace(:filename => node.filename, :line => node.line)

data/lib/sass/tree/visitors/perform.rb

@@ -1,9 +1,16 @@
 # A visitor for converting a dynamic Sass tree into a static Sass tree.
 class Sass::Tree::Visitors::Perform < Sass::Tree::Visitors::Base
+  # @param root [Tree::Node] The root node of the tree to visit.
+  # @param environment [Sass::Environment] The lexical environment.
+  # @return [Tree::Node] The resulting tree of static nodes.
+  def self.visit(root, environment = Sass::Environment.new)
+    new(environment).send(:visit, root)
+  end
+
   protected
 
-  def initialize
-    @environment = Sass::Environment.new
+  def initialize(env)
+    @environment = env
   end
 
   # If an exception is raised, this add proper metadata to the backtrace.
@@ -18,7 +25,6 @@ class Sass::Tree::Visitors::Perform < Sass::Tree::Visitors::Base
   def visit_children(parent)
     with_environment Sass::Environment.new(@environment) do
       parent.children = super.flatten
-      parent.children.each {|c| parent.check_child! c}
       parent
     end
   end
@@ -100,6 +106,13 @@ class Sass::Tree::Visitors::Perform < Sass::Tree::Visitors::Base
     end
   end
 
+  # Loads the function into the environment.
+  def visit_function(node)
+    @environment.set_function(node.name,
+      Sass::Callable.new(node.name, node.args, @environment, node.children))
+    []
+  end
+
   # Runs the child nodes if the conditional expression is true;
   # otherwise, tries the else nodes.
   def visit_if(node)
@@ -135,7 +148,7 @@ class Sass::Tree::Visitors::Perform < Sass::Tree::Visitors::Base
   # Loads a mixin into the environment.
   def visit_mixindef(node)
     @environment.set_mixin(node.name,
-      Sass::Mixin.new(node.name, node.args, @environment, node.children))
+      Sass::Callable.new(node.name, node.args, @environment, node.children))
     []
   end
 
@@ -206,6 +219,11 @@ END
     yield
   end
 
+  # Returns the value of the expression.
+  def visit_return(node)
+    throw :_sass_return, node.expr.perform(@environment)
+  end
+
   # Runs SassScript interpolation in the selector,
   # and then parses the result into a {Sass::Selector::CommaSequence}.
   def visit_rule(node)

data/test/sass/conversion_test.rb

@@ -901,6 +901,42 @@ foo {
 SCSS
   end
 
+  def test_argless_function_definition
+    assert_renders <<SASS, <<SCSS
+@function foo()
+  $var: 1 + 1
+  @return $var
+SASS
+@function foo() {
+  $var: 1 + 1;
+  @return $var; }
+SCSS
+  end
+
+  def test_function_definition_without_defaults
+    assert_renders <<SASS, <<SCSS
+@function foo($var1, $var2)
+  @if $var1
+    @return $var1 + $var2
+SASS
+@function foo($var1, $var2) {
+  @if $var1 {
+    @return $var1 + $var2; } }
+SCSS
+  end
+
+  def test_function_definition_with_defaults
+    assert_renders <<SASS, <<SCSS
+@function foo($var1, $var2: foo)
+  @if $var1
+    @return $var1 + $var2
+SASS
+@function foo($var1, $var2: foo) {
+  @if $var1 {
+    @return $var1 + $var2; } }
+SCSS
+  end
+
   def test_variable_definition
     assert_renders <<SASS, <<SCSS
 $var1: 12px + 15px

data/test/sass/engine_test.rb

@@ -39,8 +39,8 @@ MSG
     "a\n  b: c;" => 'Invalid CSS after "c": expected expression (e.g. 1px, bold), was ";"',
     ".foo ^bar\n  a: b" => ['Invalid CSS after ".foo ": expected selector, was "^bar"', 1],
     "a\n  @extend .foo ^bar" => 'Invalid CSS after ".foo ": expected selector, was "^bar"',
-    "a: b" => 'Properties aren\'t allowed at the root of a document.',
-    ":a b" => 'Properties aren\'t allowed at the root of a document.',
+    "a: b" => 'Properties are only allowed within rules, directives, or other properties.',
+    ":a b" => 'Properties are only allowed within rules, directives, or other properties.',
     "!" => 'Invalid variable: "!".',
     "$a" => 'Invalid variable: "$a".',
     "! a" => 'Invalid variable: "! a".',
@@ -87,12 +87,26 @@ MSG
     "=a(,)" => 'Invalid CSS after "(": expected variable (e.g. $foo), was ",)"',
     "=a($)" => 'Invalid CSS after "(": expected variable (e.g. $foo), was "$)"',
     "=a($foo bar)" => 'Invalid CSS after "($foo ": expected ")", was "bar)"',
-    "=foo\n  bar: baz\n+foo" => ["Properties aren't allowed at the root of a document.", 2],
+    "=foo\n  bar: baz\n+foo" => ["Properties are only allowed within rules, directives, or other properties.", 2],
     "a-\#{$b\n  c: d" => ['Invalid CSS after "a-#{$b": expected "}", was ""', 1],
     "=a($b = 1, $c)" => "Required argument $c must come before any optional arguments.",
     "=a($b = 1)\n  a: $b\ndiv\n  +a(1,2)" => "Mixin a takes 1 argument but 2 were passed.",
     "=a($b: 1)\n  a: $b\ndiv\n  +a(1,$c: 3)" => "Mixin a doesn't have an argument named $c",
     "=a($b)\n  a: $b\ndiv\n  +a" => "Mixin a is missing parameter $b.",
+    "@function foo()\n  1 + 2" => "Functions can only contain variable declarations and control directives.",
+    "@function foo()\n  foo: bar" => "Functions can only contain variable declarations and control directives.",
+    "@function foo()\n  foo: bar\n  @return 3" => ["Functions can only contain variable declarations and control directives.", 2],
+    "@function foo\n  @return 1" => ['Invalid CSS after "": expected "(", was ""', 1],
+    "@function foo(\n  @return 1" => ['Invalid CSS after "(": expected variable (e.g. $foo), was ""', 1],
+    "@function foo(b)\n  @return 1" => ['Invalid CSS after "(": expected variable (e.g. $foo), was "b)"', 1],
+    "@function foo(,)\n  @return 1" => ['Invalid CSS after "(": expected variable (e.g. $foo), was ",)"', 1],
+    "@function foo($)\n  @return 1" => ['Invalid CSS after "(": expected variable (e.g. $foo), was "$)"', 1],
+    "@function foo()\n  @return" => 'Invalid @return: expected expression.',
+    "@function foo()\n  @return 1\n    $var: val" => 'Illegal nesting: Nothing may be nested beneath return directives.',
+    "foo\n  @function bar()\n    @return 1" => ['Functions may only be defined at the root of a document.', 2],
+    "@return 1" => '@return may only be used within a function.',
+    "@if true\n  @return 1" => '@return may only be used within a function.',
+    "@mixin foo\n  @return 1\n@include foo" => ['@return may only be used within a function.', 2],
     "@else\n  a\n    b: c" => ["@else must come after @if.", 1],
     "@if false\n@else foo" => "Invalid else directive '@else foo': expected 'if <expr>'.",
     "@if false\n@else if " => "Invalid else directive '@else if': expected 'if <expr>'.",
@@ -511,7 +525,7 @@ SASS
   rescue Sass::SyntaxError => e
     assert_equal(<<CSS, Sass::SyntaxError.exception_to_css(e, opts).split("\n")[0..11].join("\n"))
 /*
-Syntax error: Properties aren't allowed at the root of a document.
+Syntax error: Properties are only allowed within rules, directives, or other properties.
         on line 4 of test_cssize_exception_css_inline.sass
 
 1: .filler
@@ -1127,6 +1141,90 @@ a
 SASS
   end
 
+  def test_basic_function
+    assert_equal(<<CSS, render(<<SASS))
+bar {
+  a: 3; }
+CSS
+@function foo()
+  @return 1 + 2
+
+bar
+  a: foo()
+SASS
+  end
+
+  def test_function_args
+    assert_equal(<<CSS, render(<<SASS))
+bar {
+  a: 3; }
+CSS
+@function plus($var1, $var2)
+  @return $var1 + $var2
+
+bar
+  a: plus(1, 2)
+SASS
+  end
+
+  def test_function_arg_default
+    assert_equal(<<CSS, render(<<SASS))
+bar {
+  a: 3; }
+CSS
+@function plus($var1, $var2: 2)
+  @return $var1 + $var2
+
+bar
+  a: plus(1)
+SASS
+  end
+
+  def test_function_arg_keyword
+    assert_equal(<<CSS, render(<<SASS))
+bar {
+  a: 1bar; }
+CSS
+@function plus($var1: 1, $var2: 2)
+  @return $var1 + $var2
+
+bar
+  a: plus($var2: bar)
+SASS
+  end
+
+  def test_function_with_if
+    assert_equal(<<CSS, render(<<SASS))
+bar {
+  a: foo;
+  b: bar; }
+CSS
+@function my-if($cond, $val1, $val2)
+  @if $cond
+    @return $val1
+  @else
+    @return $val2
+
+bar
+  a: my-if(true, foo, bar)
+  b: my-if(false, foo, bar)
+SASS
+  end
+
+  def test_function_with_var
+    assert_equal(<<CSS, render(<<SASS))
+bar {
+  a: 1; }
+CSS
+@function foo($val1, $val2)
+  $intermediate: $val1 + $val2
+  @return $intermediate/3
+
+bar
+  a: foo(1, 2)
+SASS
+  end
+
   def test_interpolation
     assert_equal("a-1 {\n  b-2-3: c-3; }\n", render(<<SASS))
 $a: 1

data/test/sass/scss/scss_test.rb

@@ -699,6 +699,38 @@ CSS
 SCSS
   end
 
+  ## Functions
+
+  def test_basic_function
+    assert_equal(<<CSS, render(<<SASS))
+bar {
+  a: 3; }
+CSS
+@function foo() {
+  @return 1 + 2;
+}
+
+bar {
+  a: foo();
+}
+SASS
+  end
+
+  def test_function_args
+    assert_equal(<<CSS, render(<<SASS))
+bar {
+  a: 3; }
+CSS
+@function plus($var1, $var2) {
+  @return $var1 + $var2;
+}
+
+bar {
+  a: plus(1, 2);
+}
+SASS
+  end
+
   ## Interpolation
 
   def test_basic_selector_interpolation

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: sass
 version: !ruby/object:Gem::Version 
-  version: 3.1.0.alpha.50
+  version: 3.1.0.alpha.51
 platform: ruby
 authors: 
 - Nathan Weizenbaum
@@ -11,7 +11,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-12-05 00:00:00 -05:00
+date: 2010-12-07 00:00:00 -05:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -133,6 +133,9 @@ files:
 - lib/sass/tree/visitors/cssize.rb
 - lib/sass/tree/visitors/perform.rb
 - lib/sass/tree/visitors/to_css.rb
+- lib/sass/tree/visitors/check_nesting.rb
+- lib/sass/tree/function_node.rb
+- lib/sass/tree/return_node.rb
 - lib/sass/util.rb
 - lib/sass/util/subset_map.rb
 - lib/sass/version.rb