sass 3.1.0.alpha.200 → 3.1.0.alpha.204

data/REVISION

@@ -1 +1 @@
-0f3659450161688ee9107d431b1cee89169c00d3
+34fb8b49f9c4ca99b1d59d7d63761a72d0210f5a

data/VERSION

@@ -1 +1 @@
-3.1.0.alpha.200
+3.1.0.alpha.204

data/lib/sass/plugin/compiler.rb

@@ -161,12 +161,15 @@ module Sass::Plugin
     #   the second is the location of the CSS file that it should be compiled to.
     def update_stylesheets(individual_files = [])
       run_updating_stylesheets individual_files
-
-      individual_files.each {|t, c| update_stylesheet(t, c)}
-
       @checked_for_updates = true
       staleness_checker = StalenessChecker.new(engine_options)
 
+      individual_files.each do |t, c|
+        if options[:always_update] || staleness_checker.stylesheet_needs_update?(c, t)
+          update_stylesheet(t, c)
+        end
+      end
+
       template_location_array.each do |template_location, css_location|
 
         Dir.glob(File.join(template_location, "**", "[^_]*.s[ca]ss")).sort.each do |file|

data/lib/sass/script/color.rb

@@ -102,7 +102,7 @@ module Sass::Script
         next if @attrs[k].nil?
         @attrs[k] = @attrs[k].to_i
         next if (0..255).include?(@attrs[k])
-        raise Sass::SyntaxError.new("#{k.to_s.capitalize} value must be between 0 and 255")
+        raise ArgumentError.new("#{k.to_s.capitalize} value must be between 0 and 255")
       end
 
       [:saturation, :lightness].each do |k|
@@ -110,11 +110,11 @@ module Sass::Script
         @attrs[k] = 0 if @attrs[k] < 0.00001 && @attrs[k] > -0.00001
         @attrs[k] = 100 if @attrs[k] - 100 < 0.00001 && @attrs[k] - 100 > -0.00001
         next if (0..100).include?(@attrs[k])
-        raise Sass::SyntaxError.new("#{k.to_s.capitalize} must be between 0 and 100")
+        raise ArgumentError.new("#{k.to_s.capitalize} must be between 0 and 100")
       end
 
       unless (0..1).include?(@attrs[:alpha])
-        raise Sass::SyntaxError.new("Alpha channel must be between 0 and 1")
+        raise ArgumentError.new("Alpha channel must be between 0 and 1")
       end
     end
 
@@ -245,7 +245,7 @@ END
       hsl = !([:hue, :saturation, :lightness] & attrs.keys).empty?
       rgb = !([:red, :green, :blue] & attrs.keys).empty?
       if hsl && rgb
-        raise ArgumentError.new("Color#with may not have both HSL and RGB keys specified")
+        raise ArgumentError.new("Cannot specify HSL and RGB values for a color at the same time")
       end
 
       if hsl

data/lib/sass/script/funcall.rb

@@ -96,16 +96,27 @@ module Sass
       private
 
       def construct_ruby_args(name, args, keywords)
-        return args if keywords.empty?
         unless signature = Functions.signature(name.to_sym, args.size, keywords.size)
+          return args if keywords.empty?
           raise Sass::SyntaxError.new("Function #{name} doesn't support keyword arguments")
         end
 
+        # If the user passes more non-keyword args than the function expects,
+        # but it does expect keyword args, Ruby's arg handling won't raise an error.
+        # Since we don't want to make functions think about this,
+        # we'll handle it for them here.
+        if signature.var_kwargs && !signature.var_args && args.size > signature.args.size
+          raise Sass::SyntaxError.new(
+            "#{args[signature.args.size].inspect} is not a keyword argument for `#{name}'")
+        elsif keywords.empty?
+          return args 
+        end
+
         args = args + signature.args[args.size..-1].map do |argname|
           if keywords.has_key?(argname)
             keywords.delete(argname)
           else
-            raise Sass::SyntaxError, "Function #{name} requires an argument named $#{argname}"
+            raise Sass::SyntaxError.new("Function #{name} requires an argument named $#{argname}")
           end
         end
 
@@ -113,7 +124,7 @@ module Sass
           if signature.var_kwargs
             args << keywords
           else
-            raise Sass::SyntaxError, "Function #{name} doesn't take an argument named $#{keywords.keys.sort.first}"
+            raise Sass::SyntaxError.new("Function #{name} doesn't take an argument named $#{keywords.keys.sort.first}")
           end
         end
 
@@ -129,6 +140,10 @@ module Sass
           end
         end
 
+        if args.size > function.args.size
+          raise ArgumentError.new("Wrong number of arguments (#{args.size} for #{function.args.size})")
+        end
+
         environment = function.args.zip(args).
           inject(Sass::Environment.new(function.environment)) do |env, ((var, default), value)|
           env.set_local_var(var.name,

data/lib/sass/script/functions.rb

@@ -88,6 +88,11 @@ module Sass::Script
   # \{#transparentize transparentize($color, $amount)} / \{#fade_out fade-out($color, $amount)}
   # : Makes a color more transparent.
   #
+  # ## Other Color Functions
+  #
+  # \{#adjust adjust($color, \[$red\], \[$green\], \[$blue\], \[$hue\], \[$saturation\], \[$lightness\], \[$alpha\]}
+  # : Increase or decrease any of the components of a color.
+  #
   # ## String Functions
   #
   # \{#unquote unquote($string)}
@@ -228,6 +233,8 @@ module Sass::Script
     #   in addition to those in `:args`.
     #   If this is true, the Ruby function will be passed a hash from strings
     #   to {Sass::Script::Literal}s as the last argument.
+    #   In addition, if this is true and `:var_args` is not,
+    #   Sass will ensure that the last argument passed is a hash.
     # 
     # @example
     #   declare :rgba, [:hex, :alpha]
@@ -308,9 +315,12 @@ module Sass::Script
       #   assert_type value, :Number
       # @param value [Sass::Script::Literal] A SassScript value
       # @param type [Symbol] The name of the type the value is expected to be
-      def assert_type(value, type)
+      # @param name [String, nil] The name of the argument.
+      def assert_type(value, type, name = nil)
         return if value.is_a?(Sass::Script.const_get(type))
-        raise ArgumentError.new("#{value.inspect} is not a #{type.to_s.downcase}")
+        err = "#{value.inspect} is not a #{type.to_s.downcase}"
+        err = "$#{name}: " + err if name
+        raise ArgumentError.new(err)
       end
     end
 
@@ -586,7 +596,7 @@ module Sass::Script
     # @raise [ArgumentError] If `color` isn't a color,
     #   or `number` isn't a number between 0 and 1
     def opacify(color, amount)
-      adjust(color, amount, :alpha, 0..1, :+)
+      _adjust(color, amount, :alpha, 0..1, :+)
     end
     declare :opacify, [:color, :amount]
 
@@ -607,7 +617,7 @@ module Sass::Script
     # @raise [ArgumentError] If `color` isn't a color,
     #   or `number` isn't a number between 0 and 1
     def transparentize(color, amount)
-      adjust(color, amount, :alpha, 0..1, :-)
+      _adjust(color, amount, :alpha, 0..1, :-)
     end
     declare :transparentize, [:color, :amount]
 
@@ -628,7 +638,7 @@ module Sass::Script
     # @raise [ArgumentError] If `color` isn't a color,
     #   or `number` isn't a number between 0% and 100%
     def lighten(color, amount)
-      adjust(color, amount, :lightness, 0..100, :+, "%")
+      _adjust(color, amount, :lightness, 0..100, :+, "%")
     end
     declare :lighten, [:color, :amount]
 
@@ -646,7 +656,7 @@ module Sass::Script
     # @raise [ArgumentError] If `color` isn't a color,
     #   or `number` isn't a number between 0% and 100%
     def darken(color, amount)
-      adjust(color, amount, :lightness, 0..100, :-, "%")
+      _adjust(color, amount, :lightness, 0..100, :-, "%")
     end
     declare :darken, [:color, :amount]
 
@@ -664,7 +674,7 @@ module Sass::Script
     # @raise [ArgumentError] If `color` isn't a color,
     #   or `number` isn't a number between 0% and 100%
     def saturate(color, amount)
-      adjust(color, amount, :saturation, 0..100, :+, "%")
+      _adjust(color, amount, :saturation, 0..100, :+, "%")
     end
     declare :saturate, [:color, :amount]
 
@@ -682,7 +692,7 @@ module Sass::Script
     # @raise [ArgumentError] If `color` isn't a color,
     #   or `number` isn't a number between 0% and 100%
     def desaturate(color, amount)
-      adjust(color, amount, :saturation, 0..100, :-, "%")
+      _adjust(color, amount, :saturation, 0..100, :-, "%")
     end
     declare :desaturate, [:color, :amount]
 
@@ -705,6 +715,189 @@ module Sass::Script
     end
     declare :adjust_hue, [:color, :degrees]
 
+    # Adjusts one or more properties of a color.
+    # This can change the red, green, blue, hue, saturation, value, and alpha properties.
+    # The properties are specified as keyword arguments,
+    # and are added to or subtracted from the color's current value for that property.
+    #
+    # `$red`, `$green`, and `$blue` properties should be between 0 and 255.
+    # `$saturation` and `$lightness` should be between 0% and 100%.
+    # `$alpha` should be between 0 and 1.
+    #
+    # All properties are optional.
+    # You can't specify both RGB properties (`$red`, `$green`, `$blue`)
+    # and HSL properties (`$hue`, `$saturation`, `$value`) at the same time.
+    #
+    # @example
+    #   adjust(#102030, $blue: 5) => #102035
+    #   adjust(#102030, $red: -5, $blue: 5) => #0b2035
+    #   adjust(hsl(25, 100%, 80%), $lightness: -30%, $alpha: -0.4) => hsla(25, 100%, 50%, 0.6)
+    # @param color [Color]
+    # @param red [Number]
+    # @param green [Number]
+    # @param blue [Number]
+    # @param hue [Number]
+    # @param saturation [Number]
+    # @param lightness [Number]
+    # @param alpha [Number]
+    # @return [Color]
+    # @raise [ArgumentError] if `color` is not a color,
+    #   if any keyword argument is not a number,
+    #   if any keyword argument is not in the legal range,
+    #   if an unexpected keyword argument is given,
+    #   or if both HSL and RGB properties are given.
+    def adjust(color, kwargs)
+      assert_type color, :Color
+      with = Sass::Util.map_hash({
+          "red" => [-255..255, ""],
+          "green" => [-255..255, ""],
+          "blue" => [-255..255, ""],
+          "hue" => nil,
+          "saturation" => [-100..100, "%"],
+          "lightness" => [-100..100, "%"],
+          "alpha" => [-1..1, ""]
+        }) do |name, (range, units)|
+
+        next unless val = kwargs.delete(name)
+        assert_type val, :Number, name
+        if range && !range.include?(val.value)
+          raise ArgumentError.new("$#{name}: Amount #{val} must be between #{range.first}#{units} and #{range.last}#{units}")
+        end
+        adjusted = color.send(name) + val.value
+        adjusted = [0, Sass::Util.restrict(adjusted, range)].max if range
+        [name.to_sym, adjusted]
+      end
+
+      unless kwargs.empty?
+        name, val = kwargs.to_a.first
+        raise ArgumentError.new("Unknown argument $#{name} (#{val})")
+      end
+
+      color.with(with)
+    end
+    declare :adjust, [:color], :var_kwargs => true
+
+    # Scales one or more properties of a color by a percentage value.
+    # Unlike \{#adjust}, which changes a color's properties by fixed amounts,
+    # \{#scale} fluidly changes them based on how high or low they already are.
+    # That means that lightening an already-light color with \{#scale}
+    # won't change the lightness much,
+    # but lightening a dark color by the same amount will change it more dramatically.
+    # This has the benefit of making `scale($color, ...)` have a similar effect
+    # regardless of what `$color` is.
+    #
+    # For example, the lightness of a color can be anywhere between 0 and 100.
+    # If `scale($color, $lightness: 40%)` is called, the resulting color's lightness
+    # will be 40% of the way between its original lightness and 100.
+    # If `scale($color, $lightness: -40%)` is called instead,
+    # the lightness will be 40% of the way between the original and 0.
+    #
+    # This can change the red, green, blue, saturation, value, and alpha properties.
+    # The properties are specified as keyword arguments.
+    # All arguments should be percentages between 0% and 100%.
+    #
+    # All properties are optional.
+    # You can't specify both RGB properties (`$red`, `$green`, `$blue`)
+    # and HSL properties (`$saturation`, `$value`) at the same time.
+    #
+    # @example
+    #   scale(hsl(120, 70, 80), $lightness: 50%) => hsl(120, 70, 90)
+    #   scale(rgb(200, 150, 170), $green: -40%, $blue: 70%) => rgb(200, 90, 229)
+    #   scale(hsl(200, 70, 80), $saturation: -90%, $alpha: -30%) => hsla(200, 7, 80, 0.7)
+    # @param color [Color]
+    # @param red [Number]
+    # @param green [Number]
+    # @param blue [Number]
+    # @param saturation [Number]
+    # @param lightness [Number]
+    # @param alpha [Number]
+    # @return [Color]
+    # @raise [ArgumentError] if `color` is not a color,
+    #   if any keyword argument is not a percentage between 0% and 100%,
+    #   if an unexpected keyword argument is given,
+    #   or if both HSL and RGB properties are given.
+    def scale(color, kwargs)
+      assert_type color, :Color
+      with = Sass::Util.map_hash({
+          "red" => 255,
+          "green" => 255,
+          "blue" => 255,
+          "saturation" => 100,
+          "lightness" => 100,
+          "alpha" => 1
+        }) do |name, max|
+
+        next unless val = kwargs.delete(name)
+        assert_type val, :Number, name
+        if !(val.numerator_units == ['%'] && val.denominator_units.empty?)
+          raise ArgumentError.new("$#{name}: Amount #{val} must be a % (e.g. #{val.value}%)")
+        elsif !(-100..100).include?(val.value)
+          raise ArgumentError.new("$#{name}: Amount #{val} must be between -100% and 100%")
+        end
+
+        current = color.send(name)
+        scale = val.value/100.0
+        diff = scale > 0 ? max - current : current
+        [name.to_sym, current + diff*scale]
+      end
+
+      unless kwargs.empty?
+        name, val = kwargs.to_a.first
+        raise ArgumentError.new("Unknown argument $#{name} (#{val})")
+      end
+
+      color.with(with)
+    end
+    declare :scale, [:color], :var_kwargs => true
+
+    # Sets on or more properties of a color.
+    # This can set the red, green, blue, hue, saturation, value, and alpha properties.
+    # The properties are specified as keyword arguments,
+    # and replace the color's current value for that property.
+    #
+    # `$red`, `$green`, and `$blue` properties should be between 0 and 255.
+    # `$saturation` and `$lightness` should be between 0% and 100%.
+    # `$alpha` should be between 0 and 1.
+    #
+    # All properties are optional.
+    # You can't specify both RGB properties (`$red`, `$green`, `$blue`)
+    # and HSL properties (`$hue`, `$saturation`, `$value`) at the same time.
+    #
+    # @example
+    #   set(#102030, $blue: 5) => #102005
+    #   set(#102030, $red: 120, $blue: 5) => #782005
+    #   set(hsl(25, 100%, 80%), $lightness: 40%, $alpha: 0.8) => hsla(25, 100%, 40%, 0.8)
+    # @param color [Color]
+    # @param red [Number]
+    # @param green [Number]
+    # @param blue [Number]
+    # @param hue [Number]
+    # @param saturation [Number]
+    # @param lightness [Number]
+    # @param alpha [Number]
+    # @return [Color]
+    # @raise [ArgumentError] if `color` is not a color,
+    #   if any keyword argument is not a number,
+    #   if any keyword argument is not in the legal range,
+    #   if an unexpected keyword argument is given,
+    #   or if both HSL and RGB properties are given.
+    def set(color, kwargs)
+      assert_type color, :Color
+      with = Sass::Util.map_hash(%w[red green blue hue saturation lightness alpha]) do |name, max|
+        next unless val = kwargs.delete(name)
+        assert_type val, :Number, name
+        [name.to_sym, val.value]
+      end
+
+      unless kwargs.empty?
+        name, val = kwargs.to_a.first
+        raise ArgumentError.new("Unknown argument $#{name} (#{val})")
+      end
+
+      color.with(with)
+    end
+    declare :set, [:color], :var_kwargs => true
+
     # Mixes together two colors.
     # Specifically, takes the average of each of the RGB components,
     # optionally weighted by the given percentage.
@@ -1110,7 +1303,7 @@ module Sass::Script
       Sass::Script::Number.new(yield(value.value), value.numerator_units, value.denominator_units)
     end
 
-    def adjust(color, amount, attr, range, op, units = "")
+    def _adjust(color, amount, attr, range, op, units = "")
       assert_type color, :Color
       assert_type amount, :Number
       unless range.include?(amount.value)

data/lib/sass/scss/parser.rb

@@ -236,8 +236,7 @@ module Sass
       end
 
       def else_directive
-        raise Sass::SyntaxError.new(
-          "Invalid CSS: @else must come after @if", :line => @line)
+        err("Invalid CSS: @else must come after @if")
       end
 
       def extend_directive
@@ -403,11 +402,9 @@ module Sass
       # no colon after the identifier, whitespace after the colon),
       # but I'm not sure the gains would be worth the added complexity.
       def declaration_or_ruleset
-        pos = @scanner.pos
-        line = @line
         old_use_property_exception, @use_property_exception =
           @use_property_exception, false
-        begin
+        decl_err = catch_error do
           decl = declaration
           unless decl && decl.has_children
             # We want an exception if it's not there,
@@ -415,17 +412,10 @@ module Sass
             tok!(/[;}]/) unless tok?(/[;}]/)
           end
           return decl
-        rescue Sass::SyntaxError => decl_err
         end
 
-        @line = line
-        @scanner.pos = pos
-
-        begin
-          return ruleset
-        rescue Sass::SyntaxError => ruleset_err
-          raise @use_property_exception ? decl_err : ruleset_err
-        end
+        ruleset_err = catch_error {return ruleset}
+        rethrow(@use_property_exception ? decl_err : ruleset_err)
       ensure
         @use_property_exception = old_use_property_exception
       end
@@ -684,7 +674,7 @@ MESSAGE
       end
 
       def nested_properties!(node, space)
-        raise Sass::SyntaxError.new(<<MESSAGE, :line => @line) unless space
+        err(<<MESSAGE) unless space
 Invalid CSS: a space is required between a property and its definition
 when it has other properties nested beneath it.
 MESSAGE
@@ -798,6 +788,9 @@ MESSAGE
         result = parser.send(*args)
         @line = parser.line
         result
+      rescue Sass::SyntaxError => e
+        throw(:_sass_parser_error, true) if @throw_error
+        raise e
       end
 
       def merge(arr)
@@ -844,9 +837,42 @@ MESSAGE
       end
 
       def expected(name)
+        throw(:_sass_parser_error, true) if @throw_error
         self.class.expected(@scanner, @expected || name, @line)
       end
 
+      def err(msg)
+        throw(:_sass_parser_error, true) if @throw_error
+        raise Sass::SyntaxError.new(msg, :line => @line)
+      end
+
+      def catch_error(&block)
+        old_throw_error, @throw_error = @throw_error, true
+        pos = @scanner.pos
+        line = @line
+        expected = @expected
+        if catch(:_sass_parser_error, &block)
+          @scanner.pos = pos
+          @line = line
+          @expected = expected
+          {:pos => pos, :line => line, :expected => @expected, :block => block}
+        end
+      ensure
+        @throw_error = old_throw_error
+      end
+
+      def rethrow(err)
+        if @throw_err
+          throw :_sass_parser_error, err
+        else
+          @scanner = StringScanner.new(@scanner.string)
+          @scanner.pos = err[:pos]
+          @line = err[:line]
+          @expected = err[:expected]
+          err[:block].call
+        end
+      end
+
       # @private
       def self.expected(scanner, expected, line)
         pos = scanner.pos

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

@@ -3,9 +3,12 @@ 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))
+    if error = (@parent && (
+          try_send("invalid_#{node_name @parent}_child?", @parent, node) ||
+          try_send("invalid_#{node_name node}_parent?", @parent, node))) ||
+        (@real_parent && (
+          try_send("invalid_#{node_name @real_parent}_real_child?", @real_parent, node) ||
+          try_send("invalid_#{node_name node}_real_parent?", @real_parent, node)))
       raise Sass::SyntaxError.new(error)
     end
     super
@@ -19,9 +22,11 @@ class Sass::Tree::Visitors::CheckNesting < Sass::Tree::Visitors::Base
     @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)
+    old_real_parent, @real_parent = @real_parent, parent
     super
   ensure
     @parent = old_parent
+    @real_parent = old_real_parent
   end
 
   def visit_root(node)
@@ -63,7 +68,24 @@ class Sass::Tree::Visitors::CheckNesting < Sass::Tree::Visitors::Base
   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)
+    if is_any_of?(@real_parent, Sass::Tree::IfNode, Sass::Tree::ForNode, Sass::Tree::WhileNode,
+        Sass::Tree::EachNode, Sass::Tree::MixinDefNode)
+      return "Import directives may not be used within control directives or mixins."
+    end
+    return if parent.is_a?(Sass::Tree::RootNode)
+    return "CSS import directives may only be used at the root of a document." if child.css_import?
+    # If this is a nested @import, we need to make sure it doesn't have anything
+    # that's legal at top-level but not in the current context (e.g. mixin defs).
+    child.imported_file.to_tree.children.each {|c| visit(c)}
+    nil
+  rescue Sass::SyntaxError => e
+    e.modify_backtrace(:filename => child.imported_file.options[:filename])
+    e.add_backtrace(:filename => child.filename, :line => child.line)
+    raise e
+  end
+
+  def invalid_import_real_parent?(parent, child)
+    
   end
 
   def invalid_mixindef_parent?(parent, child)
@@ -99,3 +121,4 @@ class Sass::Tree::Visitors::CheckNesting < Sass::Tree::Visitors::Base
     send(method, *args, &block)
   end
 end
+

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

@@ -93,8 +93,8 @@ class Sass::Tree::Visitors::Cssize < Sass::Tree::Visitors::Base
 
   # Modifies exception backtraces to include the imported file.
   def visit_import(node)
-    yield
-    node.children
+    # Don't use #visit_children to avoid adding the import node to the list of parents.
+    node.children.map {|c| visit(c)}.flatten
   rescue Sass::SyntaxError => e
     e.modify_backtrace(:filename => node.children.first.filename)
     e.add_backtrace(:filename => node.filename, :line => node.line)

data/test/sass/engine_test.rb

@@ -64,8 +64,9 @@ File to import not found or unreadable: foo.sass.
 Load path: .
 MSG
     "@import templates/basic\n  foo" => "Illegal nesting: Nothing may be nested beneath import directives.",
-    "foo\n  @import templates/basic" => "Import directives may only be used at the root of a document.",
-    "foo\n  @import #{File.dirname(__FILE__)}/templates/basic" => "Import directives may only be used at the root of a document.",
+    "foo\n  @import foo.css" => "CSS import directives may only be used at the root of a document.",
+    "@if true\n  @import foo" => "Import directives may not be used within control directives or mixins.",
+    "@mixin foo\n  @import foo" => "Import directives may not be used within control directives or mixins.",
     '$foo: "bar" "baz" !' => %Q{Invalid CSS after ""bar" "baz" ": expected expression (e.g. 1px, bold), was "!"},
     "=foo\n  :color red\n.bar\n  +bang" => "Undefined mixin 'bang'.",
     "=foo\n  :color red\n.bar\n  +bang_bop" => "Undefined mixin 'bang_bop'.",
@@ -104,6 +105,8 @@ MSG
     "@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],
+    "@function foo($a)\n  @return 1\na\n  b: foo()" => 'Function foo is missing parameter $a.',
+    "@function foo()\n  @return 1\na\n  b: foo(2)" => 'Wrong number of arguments (1 for 0) for `foo\'',
     "@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],
@@ -587,6 +590,43 @@ ERR
     assert !File.exists?(sassc_path("importee"))
   end
 
+  def test_import_in_rule
+    assert_equal(<<CSS, render(<<SASS, :load_paths => [File.dirname(__FILE__) + '/templates/']))
+.foo #foo {
+  background-color: #bbaaff; }
+
+.bar {
+  a: b; }
+  .bar #foo {
+    background-color: #bbaaff; }
+CSS
+.foo
+  @import partial
+
+.bar
+  a: b
+  @import partial
+SASS
+  end
+
+  def test_nested_import_with_toplevel_constructs
+    Sass::Engine.new(".foo\n  @import importee", :load_paths => [File.dirname(__FILE__) + '/templates/']).render
+  rescue Sass::SyntaxError => err
+    assert_equal(3, err.sass_line)
+    assert_match(/(\/|^)importee\.sass$/, err.sass_filename)
+
+    assert_hash_has(err.sass_backtrace.first,
+      :filename => err.sass_filename, :line => err.sass_line)
+
+    assert_nil(err.sass_backtrace[1][:filename])
+    assert_equal(2, err.sass_backtrace[1][:line])
+
+    assert_match(/(\/|^)importee\.sass:3$/, err.backtrace.first)
+    assert_equal("(sass):2", err.backtrace[1])
+  else
+    assert(false, "Exception not raised for importing mixins nested")
+  end
+
   def test_units
     renders_correctly "units"
   end

data/test/sass/functions_test.rb

@@ -461,6 +461,276 @@ class SassFunctionTest < Test::Unit::TestCase
     assert_error_message("\"foo\" is not a number for `adjust-hue'", "adjust-hue(#fff, \"foo\")")
   end
 
+  def test_adjust
+    # HSL
+    assert_equal(evaluate("hsl(180, 30, 90)"),
+      evaluate("adjust(hsl(120, 30, 90), $hue: 60deg)"))
+    assert_equal(evaluate("hsl(120, 50, 90)"),
+      evaluate("adjust(hsl(120, 30, 90), $saturation: 20%)"))
+    assert_equal(evaluate("hsl(120, 30, 60)"),
+      evaluate("adjust(hsl(120, 30, 90), $lightness: -30%)"))
+    # RGB
+    assert_equal(evaluate("rgb(15, 20, 30)"),
+      evaluate("adjust(rgb(10, 20, 30), $red: 5)"))
+    assert_equal(evaluate("rgb(10, 15, 30)"),
+      evaluate("adjust(rgb(10, 20, 30), $green: -5)"))
+    assert_equal(evaluate("rgb(10, 20, 40)"),
+      evaluate("adjust(rgb(10, 20, 30), $blue: 10)"))
+    # Alpha
+    assert_equal(evaluate("hsla(120, 30, 90, 0.65)"),
+      evaluate("adjust(hsl(120, 30, 90), $alpha: -0.35)"))
+    assert_equal(evaluate("rgba(10, 20, 30, 0.9)"),
+      evaluate("adjust(rgba(10, 20, 30, 0.4), $alpha: 0.5)"))
+
+    # HSL composability
+    assert_equal(evaluate("hsl(180, 20, 90)"),
+      evaluate("adjust(hsl(120, 30, 90), $hue: 60deg, $saturation: -10%)"))
+    assert_equal(evaluate("hsl(180, 20, 95)"),
+      evaluate("adjust(hsl(120, 30, 90), $hue: 60deg, $saturation: -10%, $lightness: 5%)"))
+    assert_equal(evaluate("hsla(120, 20, 95, 0.3)"),
+      evaluate("adjust(hsl(120, 30, 90), $saturation: -10%, $lightness: 5%, $alpha: -0.7)"))
+
+    # RGB composability
+    assert_equal(evaluate("rgb(15, 20, 29)"),
+      evaluate("adjust(rgb(10, 20, 30), $red: 5, $blue: -1)"))
+    assert_equal(evaluate("rgb(15, 45, 29)"),
+      evaluate("adjust(rgb(10, 20, 30), $red: 5, $green: 25, $blue: -1)"))
+    assert_equal(evaluate("rgba(10, 25, 29, 0.7)"),
+      evaluate("adjust(rgb(10, 20, 30), $green: 5, $blue: -1, $alpha: -0.3)"))
+
+    # HSL range restriction
+    assert_equal(evaluate("hsl(120, 30, 90)"),
+      evaluate("adjust(hsl(120, 30, 90), $hue: 720deg)"))
+    assert_equal(evaluate("hsl(120, 0, 90)"),
+      evaluate("adjust(hsl(120, 30, 90), $saturation: -90%)"))
+    assert_equal(evaluate("hsl(120, 30, 100)"),
+      evaluate("adjust(hsl(120, 30, 90), $lightness: 30%)"))
+
+    # RGB range restriction
+    assert_equal(evaluate("rgb(255, 20, 30)"),
+      evaluate("adjust(rgb(10, 20, 30), $red: 250)"))
+    assert_equal(evaluate("rgb(10, 0, 30)"),
+      evaluate("adjust(rgb(10, 20, 30), $green: -30)"))
+    assert_equal(evaluate("rgb(10, 20, 0)"),
+      evaluate("adjust(rgb(10, 20, 30), $blue: -40)"))
+  end
+
+  def test_adjust_tests_types
+    assert_error_message("\"foo\" is not a color for `adjust'", "adjust(foo, $hue: 10)")
+    # HSL
+    assert_error_message("$hue: \"foo\" is not a number for `adjust'",
+      "adjust(blue, $hue: foo)")
+    assert_error_message("$saturation: \"foo\" is not a number for `adjust'",
+      "adjust(blue, $saturation: foo)")
+    assert_error_message("$lightness: \"foo\" is not a number for `adjust'",
+      "adjust(blue, $lightness: foo)")
+    # RGB
+    assert_error_message("$red: \"foo\" is not a number for `adjust'",
+      "adjust(blue, $red: foo)")
+    assert_error_message("$green: \"foo\" is not a number for `adjust'",
+      "adjust(blue, $green: foo)")
+    assert_error_message("$blue: \"foo\" is not a number for `adjust'",
+      "adjust(blue, $blue: foo)")
+    # Alpha
+    assert_error_message("$alpha: \"foo\" is not a number for `adjust'",
+      "adjust(blue, $alpha: foo)")
+  end
+
+  def test_adjust_tests_arg_range
+    # HSL
+    assert_error_message("$saturation: Amount 101% must be between -100% and 100% for `adjust'",
+      "adjust(blue, $saturation: 101%)")
+    assert_error_message("$saturation: Amount -101% must be between -100% and 100% for `adjust'",
+      "adjust(blue, $saturation: -101%)")
+    assert_error_message("$lightness: Amount 101% must be between -100% and 100% for `adjust'",
+      "adjust(blue, $lightness: 101%)")
+    assert_error_message("$lightness: Amount -101% must be between -100% and 100% for `adjust'",
+      "adjust(blue, $lightness: -101%)")
+    # RGB
+    assert_error_message("$red: Amount 256 must be between -255 and 255 for `adjust'",
+      "adjust(blue, $red: 256)")
+    assert_error_message("$red: Amount -256 must be between -255 and 255 for `adjust'",
+      "adjust(blue, $red: -256)")
+    assert_error_message("$green: Amount 256 must be between -255 and 255 for `adjust'",
+      "adjust(blue, $green: 256)")
+    assert_error_message("$green: Amount -256 must be between -255 and 255 for `adjust'",
+      "adjust(blue, $green: -256)")
+    assert_error_message("$blue: Amount 256 must be between -255 and 255 for `adjust'",
+      "adjust(blue, $blue: 256)")
+    assert_error_message("$blue: Amount -256 must be between -255 and 255 for `adjust'",
+      "adjust(blue, $blue: -256)")
+    # Alpha
+    assert_error_message("$alpha: Amount 1.1 must be between -1 and 1 for `adjust'",
+      "adjust(blue, $alpha: 1.1)")
+    assert_error_message("$alpha: Amount -1.1 must be between -1 and 1 for `adjust'",
+      "adjust(blue, $alpha: -1.1)")
+  end
+
+  def test_adjust_argument_errors
+    assert_error_message("Unknown argument $hoo (260deg) for `adjust'",
+      "adjust(blue, $hoo: 260deg)")
+    assert_error_message("Cannot specify HSL and RGB values for a color at the same time for `adjust'",
+      "adjust(blue, $hue: 120deg, $red: 10)");
+    assert_error_message("10px is not a keyword argument for `adjust'",
+      "adjust(blue, 10px)")
+    assert_error_message("10px is not a keyword argument for `adjust'",
+      "adjust(blue, 10px, 20px)")
+    assert_error_message("10px is not a keyword argument for `adjust'",
+      "adjust(blue, 10px, $hue: 180deg)")
+  end
+
+  def test_scale
+    # HSL
+    assert_equal(evaluate("hsl(120, 51, 90)"),
+      evaluate("scale(hsl(120, 30, 90), $saturation: 30%)"))
+    assert_equal(evaluate("hsl(120, 30, 76.5)"),
+      evaluate("scale(hsl(120, 30, 90), $lightness: -15%)"))
+    # RGB
+    assert_equal(evaluate("rgb(157, 20, 30)"),
+      evaluate("scale(rgb(10, 20, 30), $red: 60%)"))
+    assert_equal(evaluate("rgb(10, 38.8, 30)"),
+      evaluate("scale(rgb(10, 20, 30), $green: 8%)"))
+    assert_equal(evaluate("rgb(10, 20, 20)"),
+      evaluate("scale(rgb(10, 20, 30), $blue: -(1/3)*100%)"))
+    # Alpha
+    assert_equal(evaluate("hsla(120, 30, 90, 0.86)"),
+      evaluate("scale(hsl(120, 30, 90), $alpha: -14%)"))
+    assert_equal(evaluate("rgba(10, 20, 30, 0.82)"),
+      evaluate("scale(rgba(10, 20, 30, 0.8), $alpha: 10%)"))
+
+    # HSL composability
+    assert_equal(evaluate("hsl(120, 51, 76.5)"),
+      evaluate("scale(hsl(120, 30, 90), $saturation: 30%, $lightness: -15%)"))
+    assert_equal(evaluate("hsla(120, 51, 90, 0.2)"),
+      evaluate("scale(hsl(120, 30, 90), $saturation: 30%, $alpha: -80%)"))
+
+    # RGB composability
+    assert_equal(evaluate("rgb(157, 38.8, 30)"),
+      evaluate("scale(rgb(10, 20, 30), $red: 60%, $green: 8%)"))
+    assert_equal(evaluate("rgb(157, 38.8, 20)"),
+      evaluate("scale(rgb(10, 20, 30), $red: 60%, $green: 8%, $blue: -(1/3)*100%)"))
+    assert_equal(evaluate("rgba(10, 38.8, 20, 0.55)"),
+      evaluate("scale(rgba(10, 20, 30, 0.5), $green: 8%, $blue: -(1/3)*100%, $alpha: 10%)"))
+
+    # Extremes
+    assert_equal(evaluate("hsl(120, 100, 90)"),
+      evaluate("scale(hsl(120, 30, 90), $saturation: 100%)"))
+    assert_equal(evaluate("hsl(120, 30, 90)"),
+      evaluate("scale(hsl(120, 30, 90), $saturation: 0%)"))
+    assert_equal(evaluate("hsl(120, 0, 90)"),
+      evaluate("scale(hsl(120, 30, 90), $saturation: -100%)"))
+  end
+
+  def test_scale_tests_types
+    assert_error_message("\"foo\" is not a color for `scale'", "scale(foo, $red: 10%)")
+    # HSL
+    assert_error_message("$saturation: \"foo\" is not a number for `scale'",
+      "scale(blue, $saturation: foo)")
+    assert_error_message("$lightness: \"foo\" is not a number for `scale'",
+      "scale(blue, $lightness: foo)")
+    # RGB
+    assert_error_message("$red: \"foo\" is not a number for `scale'",
+      "scale(blue, $red: foo)")
+    assert_error_message("$green: \"foo\" is not a number for `scale'",
+      "scale(blue, $green: foo)")
+    assert_error_message("$blue: \"foo\" is not a number for `scale'",
+      "scale(blue, $blue: foo)")
+    # Alpha
+    assert_error_message("$alpha: \"foo\" is not a number for `scale'",
+      "scale(blue, $alpha: foo)")
+  end
+
+  def test_scale_argument_errors
+    # Range
+    assert_error_message("$saturation: Amount 101% must be between -100% and 100% for `scale'",
+      "scale(blue, $saturation: 101%)")
+    assert_error_message("$red: Amount -101% must be between -100% and 100% for `scale'",
+      "scale(blue, $red: -101%)")
+    assert_error_message("$alpha: Amount -101% must be between -100% and 100% for `scale'",
+      "scale(blue, $alpha: -101%)")
+
+    # Unit
+    assert_error_message("$saturation: Amount 80 must be a % (e.g. 80%) for `scale'",
+      "scale(blue, $saturation: 80)")
+    assert_error_message("$alpha: Amount 0.5 must be a % (e.g. 0.5%) for `scale'",
+      "scale(blue, $alpha: 0.5)")
+
+    # Unknown argument
+    assert_error_message("Unknown argument $hue (80%) for `scale'", "scale(blue, $hue: 80%)")
+
+    # Non-keyword arg
+    assert_error_message("10px is not a keyword argument for `scale'", "scale(blue, 10px)")
+
+    # HSL/RGB
+    assert_error_message("Cannot specify HSL and RGB values for a color at the same time for `scale'",
+      "scale(blue, $lightness: 10%, $red: 20%)");
+  end
+
+  def test_set
+    # HSL
+    assert_equal(evaluate("hsl(195, 30, 90)"),
+      evaluate("set(hsl(120, 30, 90), $hue: 195deg)"))
+    assert_equal(evaluate("hsl(120, 50, 90)"),
+      evaluate("set(hsl(120, 30, 90), $saturation: 50%)"))
+    assert_equal(evaluate("hsl(120, 30, 40)"),
+      evaluate("set(hsl(120, 30, 90), $lightness: 40%)"))
+    # RGB
+    assert_equal(evaluate("rgb(123, 20, 30)"),
+      evaluate("set(rgb(10, 20, 30), $red: 123)"))
+    assert_equal(evaluate("rgb(10, 234, 30)"),
+      evaluate("set(rgb(10, 20, 30), $green: 234)"))
+    assert_equal(evaluate("rgb(10, 20, 198)"),
+      evaluate("set(rgb(10, 20, 30), $blue: 198)"))
+    # Alpha
+    assert_equal(evaluate("rgba(10, 20, 30, 0.76)"),
+      evaluate("set(rgb(10, 20, 30), $alpha: 0.76)"))
+
+    # HSL composability
+    assert_equal(evaluate("hsl(56, 30, 47)"),
+      evaluate("set(hsl(120, 30, 90), $hue: 56deg, $lightness: 47%)"))
+    assert_equal(evaluate("hsla(56, 30, 47, 0.9)"),
+      evaluate("set(hsl(120, 30, 90), $hue: 56deg, $lightness: 47%, $alpha: 0.9)"))
+  end
+
+  def test_set_tests_types
+    assert_error_message("\"foo\" is not a color for `set'", "set(foo, $red: 10%)")
+    # HSL
+    assert_error_message("$saturation: \"foo\" is not a number for `set'",
+      "set(blue, $saturation: foo)")
+    assert_error_message("$lightness: \"foo\" is not a number for `set'",
+      "set(blue, $lightness: foo)")
+    # RGB
+    assert_error_message("$red: \"foo\" is not a number for `set'", "set(blue, $red: foo)")
+    assert_error_message("$green: \"foo\" is not a number for `set'", "set(blue, $green: foo)")
+    assert_error_message("$blue: \"foo\" is not a number for `set'", "set(blue, $blue: foo)")
+    # Alpha
+    assert_error_message("$alpha: \"foo\" is not a number for `set'", "set(blue, $alpha: foo)")
+  end
+
+  def test_set_argument_errors
+    # Range
+    assert_error_message("Saturation must be between 0 and 100 for `set'",
+      "set(blue, $saturation: 101%)")
+    assert_error_message("Lightness must be between 0 and 100 for `set'",
+      "set(blue, $lightness: 101%)")
+    assert_error_message("Red value must be between 0 and 255 for `set'",
+      "set(blue, $red: -1)")
+    assert_error_message("Green value must be between 0 and 255 for `set'",
+      "set(blue, $green: 256)")
+    assert_error_message("Blue value must be between 0 and 255 for `set'",
+      "set(blue, $blue: 500)")
+
+    # Unknown argument
+    assert_error_message("Unknown argument $hoo (80%) for `set'", "set(blue, $hoo: 80%)")
+
+    # Non-keyword arg
+    assert_error_message("10px is not a keyword argument for `set'", "set(blue, 10px)")
+
+    # HSL/RGB
+    assert_error_message("Cannot specify HSL and RGB values for a color at the same time for `set'",
+      "set(blue, $lightness: 10%, $red: 120)");
+  end
+
   def test_mix
     assert_equal("#7f007f", evaluate("mix(#f00, #00f)"))
     assert_equal("#7f7f7f", evaluate("mix(#f00, #0ff)"))

data/test/sass/plugin_test.rb

@@ -74,6 +74,14 @@ class SassPluginTest < Test::Unit::TestCase
     assert_stylesheet_updated 'scss_import'
   end
 
+  def test_update_needed_when_nested_import_dependency_modified
+    touch 'basic'
+    assert_needs_update 'nested_import'
+    update_all_stylesheets!
+    assert_stylesheet_updated 'basic'
+    assert_stylesheet_updated 'scss_import'
+  end
+
   def test_full_exception_handling
     File.delete(tempfile_loc('bork1'))
     update_all_stylesheets!

data/test/sass/templates/nested_import.sass

@@ -0,0 +1,2 @@
+.foo
+  @import basic

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: sass
 version: !ruby/object:Gem::Version 
-  version: 3.1.0.alpha.200
+  version: 3.1.0.alpha.204
 platform: ruby
 authors: 
 - Nathan Weizenbaum
@@ -11,7 +11,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-12-07 00:00:00 -05:00
+date: 2010-12-17 00:00:00 -05:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -114,17 +114,17 @@ files:
 - lib/sass/tree/debug_node.rb
 - lib/sass/tree/directive_node.rb
 - lib/sass/tree/extend_node.rb
-- lib/sass/tree/if_node.rb
 - lib/sass/tree/for_node.rb
+- lib/sass/tree/if_node.rb
 - lib/sass/tree/import_node.rb
+- lib/sass/tree/mixin_def_node.rb
 - lib/sass/tree/mixin_node.rb
 - lib/sass/tree/node.rb
-- lib/sass/tree/mixin_def_node.rb
 - lib/sass/tree/prop_node.rb
 - lib/sass/tree/root_node.rb
 - lib/sass/tree/rule_node.rb
-- lib/sass/tree/warn_node.rb
 - lib/sass/tree/variable_node.rb
+- lib/sass/tree/warn_node.rb
 - lib/sass/tree/while_node.rb
 - lib/sass/tree/each_node.rb
 - lib/sass/tree/function_node.rb
@@ -248,10 +248,10 @@ files:
 - test/sass/templates/nested_bork2.sass
 - test/sass/templates/nested_bork3.sass
 - test/sass/templates/nested_bork4.sass
+- test/sass/templates/script.sass
 - test/sass/templates/nested_mixin_bork.sass
 - test/sass/templates/options.sass
 - test/sass/templates/parent_ref.sass
-- test/sass/templates/script.sass
 - test/sass/templates/scss_import.scss
 - test/sass/templates/scss_importee.scss
 - test/sass/templates/subdir/nested_subdir/_nested_partial.sass
@@ -260,6 +260,7 @@ files:
 - test/sass/templates/units.sass
 - test/sass/templates/warn.sass
 - test/sass/templates/warn_imported.sass
+- test/sass/templates/nested_import.sass
 - test/sass/test_helper.rb
 - test/sass/util/subset_map_test.rb
 - test/sass/util_test.rb