sass 3.1.21 → 3.2.0.alpha.3

data/lib/sass/plugin/configuration.rb

@@ -31,6 +31,8 @@ module Sass
       # @return [{Symbol => Object}]
       def options
         @options ||= default_options.dup
+        @options[:cache_store] ||= Sass::CacheStores::Filesystem.new(@options[:cache_location])
+        @options
       end
 
       # Sets the options hash.

data/lib/sass/plugin/staleness_checker.rb

@@ -39,10 +39,6 @@ module Sass
       def initialize(options)
         @dependencies = self.class.dependencies_cache
 
-        # URIs that are being actively checked for staleness. Protects against
-        # import loops.
-        @actively_checking = Set.new
-
         # Entries in the following instance-level caches are never explicitly expired.
         # Instead they are supposed to automaticaly go out of scope when a series of staleness checks
         # (this instance of StalenessChecker was created for) is finished.
@@ -152,16 +148,10 @@ module Sass
 
       def dependency_updated?(css_mtime)
         Proc.new do |uri, importer|
-          next true if @actively_checking.include?(uri)
-          begin
-            @actively_checking << uri
-            sass_mtime = mtime(uri, importer)
-            !sass_mtime ||
-              sass_mtime > css_mtime ||
-              dependencies_stale?(uri, importer, css_mtime)
-          ensure
-            @actively_checking.delete uri
-          end
+          sass_mtime = mtime(uri, importer)
+          !sass_mtime ||
+            sass_mtime > css_mtime ||
+            dependencies_stale?(uri, importer, css_mtime)
         end
       end
 

data/lib/sass/repl.rb

@@ -15,6 +15,7 @@ module Sass
     # Starts the read-eval-print loop.
     def run
       environment = Environment.new
+      environment.set_var('important', Script::String.new('!important'))
       @line = 0
       loop do
         @line += 1
@@ -34,8 +35,8 @@ module Sass
       case text
       when Script::MATCH
         name = $1
-        guarded = !!$3
-        val = Script::Parser.parse($2, @line, text.size - ($3 || '').size - $2.size)
+        guarded = $3 == '||=' || $4
+        val = Script::Parser.parse($3, @line, text.size - $3.size)
 
         unless guarded && environment.var(name)
           environment.set_var(name, val.perform(environment))

data/lib/sass/script.rb

@@ -1,3 +1,4 @@
+require 'strscan'
 require 'sass/script/node'
 require 'sass/script/variable'
 require 'sass/script/funcall'

data/lib/sass/script/color.rb

@@ -101,16 +101,21 @@ module Sass::Script
       [:red, :green, :blue].each do |k|
         next if @attrs[k].nil?
         @attrs[k] = @attrs[k].to_i
-        Sass::Util.check_range("#{k.to_s.capitalize} value", 0..255, @attrs[k])
+        next if (0..255).include?(@attrs[k])
+        raise ArgumentError.new("#{k.to_s.capitalize} value must be between 0 and 255")
       end
 
       [:saturation, :lightness].each do |k|
         next if @attrs[k].nil?
-        value = Number.new(@attrs[k], ['%']) # Get correct unit for error messages
-        @attrs[k] = Sass::Util.check_range("#{k.to_s.capitalize}", 0..100, value, '%')
+        @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 ArgumentError.new("#{k.to_s.capitalize} must be between 0 and 100")
       end
 
-      @attrs[:alpha] = Sass::Util.check_range("Alpha channel", 0..1, @attrs[:alpha])
+      unless (0..1).include?(@attrs[:alpha])
+        raise ArgumentError.new("Alpha channel must be between 0 and 1")
+      end
     end
 
     # The red component of the color.

data/lib/sass/script/funcall.rb

@@ -36,7 +36,7 @@ module Sass
       # @return [String] A string representation of the function call
       def inspect
         args = @args.map {|a| a.inspect}.join(', ')
-        keywords = Sass::Util.hash_to_a(@keywords).
+        keywords = @keywords.sort_by {|k, v| k}.
             map {|k, v| "$#{k}: #{v.inspect}"}.join(', ')
         "#{name}(#{args}#{', ' unless args.empty? || keywords.empty?}#{keywords})"
       end
@@ -44,7 +44,7 @@ module Sass
       # @see Node#to_sass
       def to_sass(opts = {})
         args = @args.map {|a| a.to_sass(opts)}.join(', ')
-        keywords = Sass::Util.hash_to_a(@keywords).
+        keywords = @keywords.sort_by {|k, v| k}.
           map {|k, v| "$#{dasherize(k, opts)}: #{v.to_sass(opts)}"}.join(', ')
         "#{dasherize(name, opts)}(#{args}#{', ' unless args.empty? || keywords.empty?}#{keywords})"
       end
@@ -57,14 +57,6 @@ module Sass
         @args + @keywords.values
       end
 
-      # @see Node#deep_copy
-      def deep_copy
-        node = dup
-        node.instance_variable_set('@args', args.map {|a| a.deep_copy})
-        node.instance_variable_set('@keywords', Hash[keywords.map {|k, v| [k, v.deep_copy]}])
-        node
-      end
-
       protected
 
       # Evaluates the function call.
@@ -88,12 +80,7 @@ module Sass
           opts(Functions::EvaluationContext.new(environment.options).send(ruby_name, *args))
         end
       rescue ArgumentError => e
-        # If this is a legitimate Ruby-raised argument error, re-raise it.
-        # Otherwise, it's an error in the user's stylesheet, so wrap it.
-        if e.message =~ /^wrong number of arguments \(\d+ for \d+\)/ &&
-            e.backtrace[0] !~ /:in `(block in )?#{ruby_name}'$/
-          raise e
-        end
+        raise e unless e.backtrace.any? {|t| t =~ /:in `(block in )?(#{name}|perform)'$/}
         raise Sass::SyntaxError.new("#{e.message} for `#{name}'")
       end
 

data/lib/sass/script/functions.rb

@@ -93,7 +93,7 @@ module Sass::Script
   # \{#adjust_color adjust-color($color, \[$red\], \[$green\], \[$blue\], \[$hue\], \[$saturation\], \[$lightness\], \[$alpha\]}
   # : Increase or decrease any of the components of a color.
   #
-  # \{#scale_color scale-color($color, \[$red\], \[$green\], \[$blue\], \[$saturation\], \[$lightness\], \[$alpha\]}
+  # \{#scale_color scale-color($color, \[$red\], \[$green\], \[$blue\], \[$hue\], \[$saturation\], \[$lightness\], \[$alpha\]}
   # : Fluidly scale one or more components of a color.
   #
   # \{#change_color change-color($color, \[$red\], \[$green\], \[$blue\], \[$hue\], \[$saturation\], \[$lightness\], \[$alpha\]}
@@ -135,9 +135,6 @@ module Sass::Script
   # \{#join join($list1, $list2, \[$separator\])}
   # : Joins together two lists into one.
   #
-  # \{#append append($list1, $val, \[$separator\])}
-  # : Appends a single value onto the end of a list.
-  #
   # ## Introspection Functions
   #
   # \{#type_of type-of($value)}
@@ -369,10 +366,11 @@ module Sass::Script
       Color.new([red, green, blue].map do |c|
           v = c.value
           if c.numerator_units == ["%"] && c.denominator_units.empty?
-            v = Sass::Util.check_range("Color value", 0..100, c, '%')
-            v * 255 / 100.0
+            next v * 255 / 100.0 if (0..100).include?(v)
+            raise ArgumentError.new("Color value #{c} must be between 0% and 100% inclusive")
           else
-            Sass::Util.check_range("Color value", 0..255, c)
+            next v if (0..255).include?(v)
+            raise ArgumentError.new("Color value #{v} must be between 0 and 255 inclusive")
           end
         end)
     end
@@ -412,7 +410,10 @@ module Sass::Script
         assert_type color, :Color
         assert_type alpha, :Number
 
-        Sass::Util.check_range('Alpha channel', 0..1, alpha)
+        unless (0..1).include?(alpha.value)
+          raise ArgumentError.new("Alpha channel #{alpha.value} must be between 0 and 1 inclusive")
+        end
+
         color.with(:alpha => alpha.value)
       when 4
         red, green, blue, alpha = args
@@ -462,11 +463,16 @@ module Sass::Script
       assert_type lightness, :Number
       assert_type alpha, :Number
 
-      Sass::Util.check_range('Alpha channel', 0..1, alpha)
+      unless (0..1).include?(alpha.value)
+        raise ArgumentError.new("Alpha channel #{alpha.value} must be between 0 and 1")
+      end
 
-      h = hue.value
-      s = Sass::Util.check_range('Saturation', 0..100, saturation, '%')
-      l = Sass::Util.check_range('Lightness', 0..100, lightness, '%')
+      original_s = saturation
+      original_l = lightness
+      # This algorithm is from http://www.w3.org/TR/css3-color#hsl-color
+      h, s, l = [hue, saturation, lightness].map { |a| a.value }
+      raise ArgumentError.new("Saturation #{s} must be between 0% and 100%") unless (0..100).include?(s)
+      raise ArgumentError.new("Lightness #{l} must be between 0% and 100%") unless (0..100).include?(l)
 
       Color.new(:hue => h, :saturation => s, :lightness => l, :alpha => alpha.value)
     end
@@ -576,10 +582,7 @@ module Sass::Script
         return Sass::Script::String.new("alpha(#{args.map {|a| a.to_s}.join(", ")})")
       end
 
-      raise ArgumentError.new("wrong number of arguments (#{args.size} for 1)") if args.size != 1
-
-      assert_type args.first, :Color
-      Sass::Script::Number.new(args.first.alpha)
+      opacity(*args)
     end
     declare :alpha, [:color]
 
@@ -592,7 +595,6 @@ module Sass::Script
     # @see #transparentize
     # @raise [ArgumentError] If `color` isn't a color
     def opacity(color)
-      return Sass::Script::String.new("opacity(#{color})") if color.is_a?(Sass::Script::Number)
       assert_type color, :Color
       Sass::Script::Number.new(color.alpha)
     end
@@ -683,21 +685,16 @@ module Sass::Script
     # @example
     #   saturate(hsl(120, 30%, 90%), 20%) => hsl(120, 50%, 90%)
     #   saturate(#855, 20%) => #9e3f3f
-    # @overload saturate(color, amount)
-    #   @param color [Color]
-    #   @param amount [Number]
-    #   @return [Color]
-    #   @see #desaturate
-    #   @raise [ArgumentError] If `color` isn't a color,
-    #     or `number` isn't a number between 0% and 100%
-    def saturate(color, amount = nil)
-      # Support the filter effects definition of saturate.
-      # https://dvcs.w3.org/hg/FXTF/raw-file/tip/filters/index.html
-      return Sass::Script::String.new("saturate(#{color})") if amount.nil?
+    # @param color [Color]
+    # @param amount [Number]
+    # @return [Color]
+    # @see #desaturate
+    # @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, :+, "%")
     end
     declare :saturate, [:color, :amount]
-    declare :saturate, [:amount]
 
     # Makes a color less saturated.
     # Takes a color and an amount between 0% and 100%,
@@ -781,7 +778,9 @@ module Sass::Script
 
         next unless val = kwargs.delete(name)
         assert_type val, :Number, name
-        Sass::Util.check_range("$#{name}: Amount", range, val, units) if range
+        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]
@@ -850,8 +849,8 @@ module Sass::Script
         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}%)")
-        else
-          Sass::Util.check_range("$#{name}: Amount", -100..100, val, '%')
+        elsif !(-100..100).include?(val.value)
+          raise ArgumentError.new("$#{name}: Amount #{val} must be between -100% and 100%")
         end
 
         current = color.send(name)
@@ -945,28 +944,31 @@ module Sass::Script
       assert_type color2, :Color
       assert_type weight, :Number
 
-      Sass::Util.check_range("Weight", 0..100, weight, '%')
+      unless (0..100).include?(weight.value)
+        raise ArgumentError.new("Weight #{weight} must be between 0% and 100%")
+      end
 
-      # This algorithm factors in both the user-provided weight (w) and the
-      # difference between the alpha values of the two colors (a) to decide how
-      # to perform the weighted average of the two RGB values.
+      # This algorithm factors in both the user-provided weight
+      # and the difference between the alpha values of the two colors
+      # to decide how to perform the weighted average of the two RGB values.
       #
       # It works by first normalizing both parameters to be within [-1, 1],
-      # where 1 indicates "only use color1", -1 indicates "only use color2", and
-      # all values in between indicated a proportionately weighted average.
+      # where 1 indicates "only use color1", -1 indicates "only use color 0",
+      # and all values in between indicated a proportionately weighted average.
       #
-      # Once we have the normalized variables w and a, we apply the formula
-      # (w + a)/(1 + w*a) to get the combined weight (in [-1, 1]) of color1.
+      # Once we have the normalized variables w and a,
+      # we apply the formula (w + a)/(1 + w*a)
+      # to get the combined weight (in [-1, 1]) of color1.
       # This formula has two especially nice properties:
       #
       #   * When either w or a are -1 or 1, the combined weight is also that number
       #     (cases where w * a == -1 are undefined, and handled as a special case).
       #
-      #   * When a is 0, the combined weight is w, and vice versa.
+      #   * When a is 0, the combined weight is w, and vice versa
       #
       # Finally, the weight of color1 is renormalized to be within [0, 1]
       # and the weight of color2 is given by 1 minus the weight of color1.
-      p = (weight.value/100.0).to_f
+      p = weight.value/100.0
       w = p*2 - 1
       a = color1.alpha - color2.alpha
 
@@ -988,7 +990,6 @@ module Sass::Script
     # @raise [ArgumentError] if `color` isn't a color
     # @see #desaturate
     def grayscale(color)
-      return Sass::Script::String.new("grayscale(#{color})") if color.is_a?(Sass::Script::Number)
       desaturate color, Number.new(100)
     end
     declare :grayscale, [:color]
@@ -1012,15 +1013,12 @@ module Sass::Script
     # @return [Color]
     # @raise [ArgumentError] if `color` isn't a color
     def invert(color)
-      return Sass::Script::String.new("invert(#{color})") if color.is_a?(Sass::Script::Number)
-
       assert_type color, :Color
       color.with(
         :red => (255 - color.red),
         :green => (255 - color.green),
         :blue => (255 - color.blue))
     end
-    declare :invert, [:color]
 
     # Removes quotes from a string if the string is quoted,
     # or returns the same string if it's not.
@@ -1153,8 +1151,8 @@ module Sass::Script
     # Rounds a number up to the nearest whole number.
     #
     # @example
-    #   ceil(10.4px) => 11px
-    #   ceil(10.6px) => 11px
+    #   ciel(10.4px) => 11px
+    #   ciel(10.6px) => 11px
     # @param value [Number] The number
     # @return [Number] The rounded number
     # @raise [ArgumentError] if `value` isn't a number
@@ -1276,14 +1274,14 @@ module Sass::Script
     #   append(10px 20px, 30px) => 10px 20px 30px
     #   append((blue, red), green) => blue, red, green
     #   append(10px 20px, 30px 40px) => 10px 20px (30px 40px)
-    #   append(10px, 20px, comma) => 10px, 20px
-    #   append((blue, red), green, space) => blue red green
-    # @overload append(list, val, separator: auto)
-    #   @param list [Literal] The list to add the value to
-    #   @param val [Literal] The value to add to the end of the list
+    #   join(10px, 20px, comma) => 10px, 20px
+    #   join((blue, red), green, space) => blue red green
+    # @overload join(list, val, separator: auto)
+    #   @param list1 [Literal] The first list to join
+    #   @param list2 [Literal] The second list to join
     #   @param separator [String] How the list separator (comma or space) should be determined.
     #     If this is `comma` or `space`, that is always the separator;
-    #     if this is `auto` (the default), the separator is the same as that used by the list.
+    #     if this is `auto` (the default), the separator is determined as explained above.
     def append(list, val, separator = Sass::Script::String.new("auto"))
       assert_type separator, :String
       unless %w[auto space comma].include?(separator.value)
@@ -1301,49 +1299,6 @@ module Sass::Script
     declare :append, [:list, :val]
     declare :append, [:list, :val, :separator]
 
-    # Combines several lists into a single comma separated list
-    # space separated lists.
-    #
-    # The length of the resulting list is the length of the
-    # shortest list.
-    #
-    # @example
-    #   zip(1px 1px 3px, solid dashed solid, red green blue)
-    #   => 1px solid red, 1px dashed green, 3px solid blue
-    def zip(*lists)
-      length = nil
-      values = []
-      lists.each do |list|
-        assert_type list, :List
-        values << list.value.dup
-        length = length.nil? ? list.value.length : [length, list.value.length].min
-      end
-      values.each do |value|
-        value.slice!(length)
-      end
-      new_list_value = values.first.zip(*values[1..-1])
-      List.new(new_list_value.map{|list| List.new(list, :space)}, :comma)
-    end
-    declare :zip, [], :var_args => true
-
-
-    # Returns the position of the given value within the given
-    # list. If not found, returns false.
-    #
-    # @example
-    #   index(1px solid red, solid) => 2
-    #   index(1px solid red, dashed) => false
-    def index(list, value)
-      assert_type list, :List
-      index = list.value.index {|e| e.eq(value).to_bool }
-      if index
-        Number.new(index + 1)
-      else
-        Bool.new(false)
-      end
-    end
-    declare :index, [:list, :value]
-
     # Returns one of two values based on the truth value of the first argument.
     #
     # @example
@@ -1374,7 +1329,9 @@ module Sass::Script
     def _adjust(color, amount, attr, range, op, units = "")
       assert_type color, :Color
       assert_type amount, :Number
-      Sass::Util.check_range('Amount', range, amount, units)
+      unless range.include?(amount.value)
+        raise ArgumentError.new("Amount #{amount} must be between #{range.first}#{units} and #{range.last}#{units}")
+      end
 
       # TODO: is it worth restricting here,
       # or should we do so in the Color constructor itself,

data/lib/sass/script/interpolation.rb

@@ -50,15 +50,6 @@ module Sass::Script
       [@before, @mid, @after].compact
     end
 
-    # @see Node#deep_copy
-    def deep_copy
-      node = dup
-      node.instance_variable_set('@before', @before.deep_copy) if @before
-      node.instance_variable_set('@mid', @mid.deep_copy)
-      node.instance_variable_set('@after', @after.deep_copy) if @after
-      node
-    end
-
     protected
 
     # Evaluates the interpolation.

data/lib/sass/script/lexer.rb

@@ -1,5 +1,7 @@
 require 'sass/scss/rx'
 
+require 'strscan'
+
 module Sass
   module Script
     # The lexical analyzer for SassScript.
@@ -124,7 +126,7 @@ module Sass
       # @param options [{Symbol => Object}] An options hash;
       #   see {file:SASS_REFERENCE.md#sass_options the Sass options documentation}
       def initialize(str, line, offset, options)
-        @scanner = str.is_a?(StringScanner) ? str : Sass::Util::MultibyteStringScanner.new(str)
+        @scanner = str.is_a?(StringScanner) ? str : StringScanner.new(str)
         @line = line
         @offset = offset
         @options = options
@@ -287,7 +289,7 @@ MESSAGE
       end
 
       def special_fun
-        return unless str1 = scan(/((-[\w-]+-)?(calc|element)|expression|progid:[a-z\.]*)\(/i)
+        return unless str1 = scan(/((-[\w-]+-)?calc|expression|progid:[a-z\.]*)\(/i)
         str2, _ = Sass::Shared.balance(@scanner, ?(, ?), 1)
         c = str2.count("\n")
         old_line = @line