haml 3.1.0 → 3.1.1

data/vendor/sass/lib/sass/script/functions.rb

@@ -88,6 +88,17 @@ module Sass::Script
   # \{#transparentize transparentize($color, $amount)} / \{#fade_out fade-out($color, $amount)}
   # : Makes a color more transparent.
   #
+  # ## Other Color Functions
+  #
+  # \{#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\], \[$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\]}
+  # : Changes one or more properties of a color.
+  #
   # ## String Functions
   #
   # \{#unquote unquote($string)}
@@ -138,6 +149,11 @@ module Sass::Script
   # \{#comparable comparable($number-1, $number-2)}
   # : Returns whether two numbers can be added or compared.
   #
+  # ## Miscellaneous Functions
+  #
+  # \{#if if($condition, $if-true, $if-false)}
+  # : Returns one of two values, depending on whether or not a condition is true.
+  #
   # ## Adding Custom Functions
   #
   # New Sass functions can be added by adding Ruby methods to this module.
@@ -223,6 +239,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]
@@ -277,6 +295,8 @@ module Sass::Script
     # That means that all instance methods of {EvaluationContext}
     # are available to use in functions.
     class EvaluationContext
+      include Functions
+
       # The options hash for the {Sass::Engine} that is processing the function call
       #
       # @return [{Symbol => Object}]
@@ -285,10 +305,6 @@ module Sass::Script
       # @param options [{Symbol => Object}] See \{#options}
       def initialize(options)
         @options = options
-
-        # We need to include this individually in each instance
-        # because of an icky Ruby restriction
-        class << self; include Sass::Script::Functions; end
       end
 
       # Asserts that the type of a given SassScript value
@@ -303,14 +319,31 @@ 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
 
-    instance_methods.each { |m| undef_method m unless m.to_s =~ /^__/ }
-
+    class << self
+      # Returns whether user function with a given name exists.
+      #
+      # @param function_name [String]
+      # @return [Boolean]
+      alias_method :callable?, :public_method_defined?
+
+      private
+      def include(*args)
+        r = super
+        # We have to re-include ourselves into EvaluationContext to work around
+        # an icky Ruby restriction.
+        EvaluationContext.send :include, self
+        r
+      end
+    end
 
     # Creates a {Color} object from red, green, and blue values.
     #
@@ -581,7 +614,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]
 
@@ -602,7 +635,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]
 
@@ -623,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 lighten(color, amount)
-      adjust(color, amount, :lightness, 0..100, :+, "%")
+      _adjust(color, amount, :lightness, 0..100, :+, "%")
     end
     declare :lighten, [:color, :amount]
 
@@ -641,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 darken(color, amount)
-      adjust(color, amount, :lightness, 0..100, :-, "%")
+      _adjust(color, amount, :lightness, 0..100, :-, "%")
     end
     declare :darken, [:color, :amount]
 
@@ -659,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 saturate(color, amount)
-      adjust(color, amount, :saturation, 0..100, :+, "%")
+      _adjust(color, amount, :saturation, 0..100, :+, "%")
     end
     declare :saturate, [:color, :amount]
 
@@ -677,7 +710,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]
 
@@ -700,6 +733,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-color(#102030, $blue: 5) => #102035
+    #   adjust-color(#102030, $red: -5, $blue: 5) => #0b2035
+    #   adjust-color(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(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, [:color], :var_kwargs => true
+
+    # Scales one or more properties of a color by a percentage value.
+    # Unlike \{#adjust_color adjust-color}, which changes a color's properties by fixed amounts,
+    # \{#scale_color scale-color} fluidly changes them based on how high or low they already are.
+    # That means that lightening an already-light color with \{#scale_color scale-color}
+    # 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($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($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($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-color(hsl(120, 70, 80), $lightness: 50%) => hsl(120, 70, 90)
+    #   scale-color(rgb(200, 150, 170), $green: -40%, $blue: 70%) => rgb(200, 90, 229)
+    #   scale-color(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(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, [:color], :var_kwargs => true
+
+    # Changes 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 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
+    #   change-color(#102030, $blue: 5) => #102005
+    #   change-color(#102030, $red: 120, $blue: 5) => #782005
+    #   change-color(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 change_color(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 :change_color, [:color], :var_kwargs => true
+
     # Mixes together two colors.
     # Specifically, takes the average of each of the RGB components,
     # optionally weighted by the given percentage.
@@ -815,8 +1031,11 @@ module Sass::Script
     #   unquote("foo") => foo
     #   unquote(foo) => foo
     def unquote(string)
-      assert_type string, :String
-      Sass::Script::String.new(string.value, :identifier)
+      if string.is_a?(Sass::Script::String)
+        Sass::Script::String.new(string.value, :identifier)
+      else
+        string
+      end
     end
     declare :unquote, [:string]
 
@@ -998,6 +1217,8 @@ module Sass::Script
         raise ArgumentError.new("List index #{n} must be an integer")
       elsif n.to_i < 1
         raise ArgumentError.new("List index #{n} must be greater than or equal to 1")
+      elsif list.to_a.size == 0
+        raise ArgumentError.new("List index is #{n} but list has no items")
       elsif n.to_i > (size = list.to_a.size)
         raise ArgumentError.new("List index is #{n} but list is only #{size} item#{'s' if size != 1} long")
       end
@@ -1030,8 +1251,8 @@ module Sass::Script
       unless %w[auto space comma].include?(separator.value)
         raise ArgumentError.new("Separator name must be space, comma, or auto")
       end
-      sep1 = list1.separator if list1.is_a?(Sass::Script::List)
-      sep2 = list2.separator if list2.is_a?(Sass::Script::List)
+      sep1 = list1.separator if list1.is_a?(Sass::Script::List) && !list1.value.empty?
+      sep2 = list2.separator if list2.is_a?(Sass::Script::List) && !list2.value.empty?
       Sass::Script::List.new(
         list1.to_a + list2.to_a,
         if separator.value == 'auto'
@@ -1078,6 +1299,23 @@ module Sass::Script
     declare :append, [:list, :val]
     declare :append, [:list, :val, :separator]
 
+    # Returns one of two values based on the truth value of the first argument.
+    #
+    # @example
+    #   if(true, 1px, 2px) => 1px
+    #   if(false, 1px, 2px) => 2px
+    # @param condition [Bool] Whether the first or second value will be returned.
+    # @param if_true [Literal] The value that will be returned if `$condition` is true.
+    # @param if_false [Literal] The value that will be returned if `$condition` is false.
+    def if(condition, if_true, if_false)
+      if condition.to_bool
+        if_true
+      else
+        if_false
+      end
+    end
+    declare :if, [:condition, :if_true, :if_false]
+
     private
 
     # This method implements the pattern of transforming a numeric value into
@@ -1088,7 +1326,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/vendor/sass/lib/sass/script/lexer.rb

@@ -87,7 +87,7 @@ module Sass
         :whitespace => /\s+/,
         :comment => COMMENT,
         :single_line_comment => SINGLE_LINE_COMMENT,
-        :variable => /([!\$])(#{IDENT})/,
+        :variable => /(\$)(#{IDENT})/,
         :ident => /(#{IDENT})(\()?/,
         :number => /(-)?(?:(\d*\.\d+)|(\d+))([a-zA-Z%]+)?/,
         :color => HEXCOLOR,
@@ -242,9 +242,6 @@ module Sass
         line = @line
         offset = @offset
         return unless scan(rx)
-        if @scanner[1] == '!' && @scanner[2] != 'important'
-          Script.var_warning(@scanner[2], line, offset + 1, @options[:filename])
-        end
 
         [:const, @scanner[2]]
       end

data/vendor/sass/lib/sass/script/list.rb

@@ -33,7 +33,8 @@ module Sass::Script
 
     # @see Node#to_s
     def to_s(opts = {})
-      return value.map {|e| e.to_s(opts)}.join(sep_str)
+      raise Sass::SyntaxError.new("() isn't a valid CSS value.") if value.empty?
+      return value.reject {|e| e.is_a?(List) && e.value.empty?}.map {|e| e.to_s(opts)}.join(sep_str)
     end
 
     # @see Node#to_sass
@@ -61,7 +62,6 @@ module Sass::Script
         value.map {|e| e.perform(environment)},
         separator)
       list.options = self.options
-      list.context = self.context
       list
     end
 

data/vendor/sass/lib/sass/script/node.rb

@@ -8,18 +8,6 @@ module Sass::Script
     # @return [{Symbol => Object}]
     attr_reader :options
 
-    # The context in which this node was parsed,
-    # which determines how some operations are performed.
-    #
-    # Can be `:equals`, which means it's part of a `$var = val` or `prop = val` assignment,
-    # or `:default`, which means it's anywhere else
-    # (including `$var: val` and `prop: val` assignments,
-    # `#{}`-interpolations,
-    # and other script contexts such as `@if` conditions).
-    #
-    # @return [Symbol]
-    attr_reader :context
-
     # The line of the document on which this node appeared.
     #
     # @return [Fixnum]
@@ -41,21 +29,6 @@ module Sass::Script
       end
     end
 
-    # Sets the context for this node,
-    # as well as for all child nodes.
-    #
-    # @param context [Symbol]
-    # @see #context
-    def context=(context)
-      @context = context
-      children.each {|c| c.context = context}
-    end
-
-    # Creates a new script node.
-    def initialize
-      @context = :default
-    end
-
     # Evaluates the node.
     #
     # \{#perform} shouldn't be overridden directly;