Module: Sass::Script::Functions

Included in:
EvaluationContext
Defined in:
lib/sass/script/functions.rb

Overview

Methods in this module are accessible from the SassScript context. For example, you can write

$color: hsl(120deg, 100%, 50%)

and it will call #hsl.

The following functions are provided:

Note: These functions are described in more detail below.

RGB Functions

rgb($red, $green, $blue)
Creates a Color from red, green, and blue values.
rgba($red, $green, $blue, $alpha)
Creates a Color from red, green, blue, and alpha values.
red($color)
Gets the red component of a color.
green($color)
Gets the green component of a color.
blue($color)
Gets the blue component of a color.
mix($color1, $color2, [$weight])
Mixes two colors together.

HSL Functions

hsl($hue, $saturation, $lightness)
Creates a Color from hue, saturation, and lightness values.
hsla($hue, $saturation, $lightness, $alpha)
Creates a Color from hue, saturation, lightness, and alpha values.
hue($color)
Gets the hue component of a color.
saturation($color)
Gets the saturation component of a color.
lightness($color)
Gets the lightness component of a color.
adjust-hue($color, $degrees)
Changes the hue of a color.
lighten($color, $amount)
Makes a color lighter.
darken($color, $amount)
Makes a color darker.
saturate($color, $amount)
Makes a color more saturated.
desaturate($color, $amount)
Makes a color less saturated.
grayscale($color)
Converts a color to grayscale.
complement($color)
Returns the complement of a color.
invert($color)
Returns the inverse of a color.

Opacity Functions

alpha($color) / opacity($color)
Gets the alpha component (opacity) of a color.
rgba($color, $alpha)
Changes the alpha component for a color.
opacify($color, $amount) / fade-in($color, $amount)
Makes a color more opaque.
transparentize($color, $amount) / fade-out($color, $amount)
Makes a color more transparent.

Other Color Functions

adjust-color($color, [$red], [$green], [$blue], [$hue], [$saturation], [$lightness], [$alpha])
Increases or decreases one or more components of a color.
scale-color($color, [$red], [$green], [$blue], [$saturation], [$lightness], [$alpha])
Fluidly scales one or more properties of a color.
change-color($color, [$red], [$green], [$blue], [$hue], [$saturation], [$lightness], [$alpha])
Changes one or more properties of a color.
ie-hex-str($color)
Converts a color into the format understood by IE filters.

String Functions

unquote($string)
Removes quotes from a string.
quote($string)
Adds quotes to a string.
str-length($string)
Returns the number of characters in a string.
str-insert($string, $insert, $index)
Inserts $insert into $string at $index.
str-index($string, $substring)
Returns the index of the first occurance of $substring in $string.
str-slice($string, $start-at, [$end-at])
Extracts a substring from $string.
to-upper-case($string)
Converts a string to upper case.
to-lower-case($string)
Converts a string to lower case.

Number Functions

percentage($number)
Converts a unitless number to a percentage.
round($number)
Rounds a number to the nearest whole number.
ceil($number)
Rounds a number up to the next whole number.
floor($number)
Rounds a number down to the previous whole number.
abs($number)
Returns the absolute value of a number.
min($numbers…)
Finds the minimum of several numbers.
max($numbers…)
Finds the maximum of several numbers.
random([$limit])
Returns a random number.

List Functions

All list functions work for maps as well, treating them as lists of pairs.

length($list)
Returns the length of a list.
nth($list, $n)
Returns a specific item in a list.
join($list1, $list2, [$separator])
Joins together two lists into one.
append($list1, $val, [$separator])
Appends a single value onto the end of a list.
zip($lists…)
Combines several lists into a single multidimensional list.
index($list, $value)
Returns the position of a value within a list.
list-separator(#list)
Returns the separator of a list.

Map Functions

map-get($map, $key)
Returns the value in a map associated with a given key.
map-merge($map1, $map2)
Merges two maps together into a new map.
map-remove($map, $key)
Returns a new map with a key removed.
map-keys($map)
Returns a list of all keys in a map.
map-values($map)
Returns a list of all values in a map.
map-has-key($map, $key)
Returns whether a map has a value associated with a given key.
keywords($args)
Returns the keywords passed to a function that takes variable arguments.

Introspection Functions

feature-exists($feature)
Returns whether a feature exists in the current Sass runtime.
variable-exists($name)
Returns whether a variable with the given name exists in the current scope.
global-variable-exists($name)
Returns whether a variable with the given name exists in the global scope.
function-exists($name)
Returns whether a function with the given name exists.
mixin-exists($name)
Returns whether a mixin with the given name exists.
inspect($value)
Returns the string representation of a value as it would be represented in Sass.
type-of($value)
Returns the type of a value.
unit($number)
Returns the unit(s) associated with a number.
unitless($number)
Returns whether a number has units.
comparable($number1, $number2)
Returns whether two numbers can be added, subtracted, or compared.
call($name, $args…)
Dynamically calls a Sass function.

Miscellaneous Functions

if($condition, $if-true, $if-false)
Returns one of two values, depending on whether or not $condition is true.
unique-id()
Returns a unique CSS identifier.

Adding Custom Functions

New Sass functions can be added by adding Ruby methods to this module. For example:

module Sass::Script::Functions
  def reverse(string)
    assert_type string, :String
    Sass::Script::Value::String.new(string.value.reverse)
  end
  declare :reverse, [:string]
end

Calling Functions.declare tells Sass the argument names for your function. If omitted, the function will still work, but will not be able to accept keyword arguments. Functions.declare can also allow your function to take arbitrary keyword arguments.

There are a few things to keep in mind when modifying this module. First of all, the arguments passed are Value objects. Value objects are also expected to be returned. This means that Ruby values must be unwrapped and wrapped.

Most Value objects support the value accessor for getting their Ruby values. Color objects, though, must be accessed using rgb, red, green, or blue.

Second, making Ruby functions accessible from Sass introduces the temptation to do things like database access within stylesheets. This is generally a bad idea; since Sass files are by default only compiled once, dynamic code is not a great fit.

If you really, really need to compile Sass on each request, first make sure you have adequate caching set up. Then you can use Engine to render the code, using the options parameter to pass in data that can be accessed from your Sass functions.

Within one of the functions in this module, methods of EvaluationContext can be used.

Caveats

When creating new Value objects within functions, be aware that it’s not safe to call #to_s (or other methods that use the string representation) on those objects without first setting the #options attribute.

Defined Under Namespace

Classes: EvaluationContext, Signature

Class Method Summary collapse

Instance Method Summary collapse

Class Method Details

.declare(method_name, args, options = {})

Declare a Sass signature for a Ruby-defined function. This includes the names of the arguments, whether the function takes a variable number of arguments, and whether the function takes an arbitrary set of keyword arguments.

It’s not necessary to declare a signature for a function. However, without a signature it won’t support keyword arguments.

A single function can have multiple signatures declared as long as each one takes a different number of arguments. It’s also possible to declare multiple signatures that all take the same number of arguments, but none of them but the first will be used unless the user uses keyword arguments.

Examples:

declare :rgba, [:hex, :alpha]
declare :rgba, [:red, :green, :blue, :alpha]
declare :accepts_anything, [], :var_args => true, :var_kwargs => true
declare :some_func, [:foo, :bar, :baz], :var_kwargs => true

Parameters:

  • method_name (Symbol) —

    The name of the method whose signature is being declared.

  • args (Array<Symbol>) —

    The names of the arguments for the function signature.

  • options (Hash) (defaults to: {}) —

    a customizable set of options

Options Hash (options):

  • :var_args (Boolean) — default: false —

    Whether the function accepts a variable number of (unnamed) arguments in addition to the named arguments.

  • :var_kwargs (Boolean) — default: false —

    Whether the function accepts other keyword arguments in addition to those in :args. If this is true, the Ruby function will be passed a hash from strings to Values 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.



354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
 
# File 'lib/sass/script/functions.rb', line 354

def self.declare(method_name, args, options = {})
  delayed_args = []
  args = args.map do |a|
    a = a.to_s
    if a[0] == ?&
      a = a[1..-1]
      delayed_args << a
    end
    a
  end
  # We don't expose this functionality except to certain builtin methods.
  if delayed_args.any? && method_name != :if
    raise ArgumentError.new("Delayed arguments are not allowed for method #{method_name}")
  end
  @signatures[method_name] ||= []
  @signatures[method_name] << Signature.new(
    args,
    delayed_args,
    options[:var_args],
    options[:var_kwargs],
    options[:deprecated] && options[:deprecated].map {|a| a.to_s})
end

.random_number_generator ⇒ Random

Get Sass’s internal random number generator.

Returns:

  • (Random) 


428
429
430
 
# File 'lib/sass/script/functions.rb', line 428

def self.random_number_generator
  @random_number_generator ||= Sass::Util::CrossPlatformRandom.new
end

.random_seed=(seed) ⇒ Integer

Sets the random seed used by Sass’s internal random number generator.

This can be used to ensure consistent random number sequences which allows for consistent results when testing, etc.

Parameters:

  • seed (Integer)

Returns:

  • (Integer) —

    The same seed.



421
422
423
 
# File 'lib/sass/script/functions.rb', line 421

def self.random_seed=(seed)
  @random_number_generator = Sass::Util::CrossPlatformRandom.new(seed)
end

.signature(method_name, arg_arity, kwarg_arity) ⇒ {Symbol => Object}?

Determine the correct signature for the number of arguments passed in for a given function. If no signatures match, the first signature is returned for error messaging.

Parameters:

  • method_name (Symbol) —

    The name of the Ruby function to be called.

  • arg_arity (Fixnum) —

    The number of unnamed arguments the function was passed.

  • kwarg_arity (Fixnum) —

    The number of keyword arguments the function was passed.

Returns:

  • ({Symbol => Object}, nil) —

    The signature options for the matching signature, or nil if no signatures are declared for this function. See declare.



388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
 
# File 'lib/sass/script/functions.rb', line 388

def self.signature(method_name, arg_arity, kwarg_arity)
  return unless @signatures[method_name]
  @signatures[method_name].each do |signature|
    sig_arity = signature.args.size
    return signature if sig_arity == arg_arity + kwarg_arity
    next unless sig_arity < arg_arity + kwarg_arity

    # We have enough args.
    # Now we need to figure out which args are varargs
    # and if the signature allows them.
    t_arg_arity, t_kwarg_arity = arg_arity, kwarg_arity
    if sig_arity > t_arg_arity
      # we transfer some kwargs arity to args arity
      # if it does not have enough args -- assuming the names will work out.
      t_kwarg_arity -= (sig_arity - t_arg_arity)
      t_arg_arity = sig_arity
    end

    if   (t_arg_arity == sig_arity ||   t_arg_arity > sig_arity && signature.var_args) &&
       (t_kwarg_arity == 0         || t_kwarg_arity > 0         && signature.var_kwargs)
      return signature
    end
  end
  @signatures[method_name].first
end

Instance Method Details

#abs($number) ⇒ Sass::Script::Value::Number

Returns the absolute value of a number.

Examples:

abs(10px) => 10px
abs(-10px) => 10px

Parameters:

Returns:

Raises:

  • (ArgumentError) —

    if $number isn’t a number



1665
1666
1667
 
# File 'lib/sass/script/functions.rb', line 1665

def abs(number)
  numeric_transformation(number) {|n| n.abs}
end

#adjust_color($color, [$red], [$green], [$blue], [$hue], [$saturation], [$lightness], [$alpha]) ⇒ Sass::Script::Value::Color

Increases or decreases 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.

All properties are optional. You can’t specify both RGB properties ($red, $green, $blue) and HSL properties ($hue, $saturation, $value) at the same time.

Examples:

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)

Parameters:

Returns:

Raises:

  • (ArgumentError) —

    if any parameter is the wrong type or out-of bounds, or if RGB properties and HSL properties are adjusted at the same time



1053
1054
1055
1056
1057
1058
1059
1060
1061
1062
1063
1064
1065
1066
1067
1068
1069
1070
1071
1072
1073
1074
1075
1076
1077
1078
1079
1080
 
# File 'lib/sass/script/functions.rb', line 1053

def adjust_color(color, kwargs)
  assert_type color, :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)|

    val = kwargs.delete(name)
    next unless val
    assert_type val, :Number, name
    Sass::Util.check_range("$#{name}: Amount", range, val, units) if range
    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

#adjust_hue($color, $degrees) ⇒ Sass::Script::Value::Color

Changes the hue of a color. Takes a color and a number of degrees (usually between -360deg and 360deg), and returns a color with the hue rotated along the color wheel by that amount.

Examples:

adjust-hue(hsl(120, 30%, 90%), 60deg) => hsl(180, 30%, 90%)
adjust-hue(hsl(120, 30%, 90%), -60deg) => hsl(60, 30%, 90%)
adjust-hue(#811, 45deg) => #886a11

Parameters:

Returns:

Raises:

  • (ArgumentError) —

    if either parameter is the wrong type



991
992
993
994
995
 
# File 'lib/sass/script/functions.rb', line 991

def adjust_hue(color, degrees)
  assert_type color, :Color, :color
  assert_type degrees, :Number, :degrees
  color.with(:hue => color.hue + degrees.value)
end

#alpha($color) ⇒ Sass::Script::Value::Number

Returns the alpha component (opacity) of a color. This is 1 unless otherwise specified.

This function also supports the proprietary Microsoft alpha(opacity=20) syntax as a special case.

Parameters:

Returns:

Raises:

  • (ArgumentError) —

    if $color isn’t a color



821
822
823
824
825
826
827
828
829
830
831
832
833
834
 
# File 'lib/sass/script/functions.rb', line 821

def alpha(*args)
  if args.all? do |a|
       a.is_a?(Sass::Script::Value::String) && a.type == :identifier &&
         a.value =~ /^[a-zA-Z]+\s*=/
     end
    # Support the proprietary MS alpha() function
    return identifier("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, :color
  number(args.first.alpha)
end

#append($list, $val, $separator: auto) ⇒ Sass::Script::Value::List

Appends a single value onto the end of a list.

Unless the $separator argument is passed, if the list had only one item, the resulting list will be space-separated.

Examples:

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

Parameters:

Returns:



1833
1834
1835
1836
1837
1838
1839
1840
1841
1842
1843
1844
 
# File 'lib/sass/script/functions.rb', line 1833

def append(list, val, separator = identifier("auto"))
  assert_type separator, :String, :separator
  unless %w[auto space comma].include?(separator.value)
    raise ArgumentError.new("Separator name must be space, comma, or auto")
  end
  sep = if separator.value == 'auto'
          list.separator || :space
        else
          separator.value.to_sym
        end
  list(list.to_a + [val], sep)
end

#blue($color) ⇒ Sass::Script::Value::Number

Gets the blue component of a color. Calculated from HSL where necessary via this algorithm.

Parameters:

Returns:

Raises:

  • (ArgumentError) —

    if $color isn’t a color



751
752
753
754
 
# File 'lib/sass/script/functions.rb', line 751

def blue(color)
  assert_type color, :Color, :color
  number(color.blue)
end

#call($name, $args...)

Dynamically calls a function. This can call user-defined functions, built-in functions, or plain CSS functions. It will pass along all arguments, including keyword arguments, to the called function.

Examples:

call(rgb, 10, 100, 255) => #0a64ff
call(scale-color, #0a64ff, $lightness: -10%) => #0058ef

$fn: nth;
call($fn, (a b c), 2) => b

Parameters:

  • $name (String) —

    The name of the function to call.



2095
2096
2097
2098
2099
2100
2101
2102
2103
2104
2105
2106
 
# File 'lib/sass/script/functions.rb', line 2095

def call(name, *args)
  assert_type name, :String, :name
  kwargs = args.last.is_a?(Hash) ? args.pop : {}
  funcall = Sass::Script::Tree::Funcall.new(
    name.value,
    args.map {|a| Sass::Script::Tree::Literal.new(a)},
    Sass::Util.map_vals(kwargs) {|v| Sass::Script::Tree::Literal.new(v)},
    nil,
    nil)
  funcall.options = options
  perform(funcall)
end

#ceil($number) ⇒ Sass::Script::Value::Number

Rounds a number up to the next whole number.

Examples:

ceil(10.4px) => 11px
ceil(10.6px) => 11px

Parameters:

Returns:

Raises:

  • (ArgumentError) —

    if $number isn’t a number



1637
1638
1639
 
# File 'lib/sass/script/functions.rb', line 1637

def ceil(number)
  numeric_transformation(number) {|n| n.ceil}
end

#change_color($color, [$red], [$green], [$blue], [$hue], [$saturation], [$lightness], [$alpha]) ⇒ Sass::Script::Value::Color

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.

All properties are optional. You can’t specify both RGB properties ($red, $green, $blue) and HSL properties ($hue, $saturation, $value) at the same time.

Examples:

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)

Parameters:

Returns:

Raises:

  • (ArgumentError) —

    if any parameter is the wrong type or out-of bounds, or if RGB properties and HSL properties are adjusted at the same time



1195
1196
1197
1198
1199
1200
1201
1202
1203
1204
1205
1206
1207
1208
1209
1210
 
# File 'lib/sass/script/functions.rb', line 1195

def change_color(color, kwargs)
  assert_type color, :Color, :color
  with = Sass::Util.to_hash(%w[red green blue hue saturation lightness alpha].map do |name|
    val = kwargs.delete(name)
    next unless val
    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

#comparable($number1, $number2) ⇒ Sass::Script::Value::Bool

Returns whether two numbers can added, subtracted, or compared.

Examples:

comparable(2px, 1px) => true
comparable(100px, 3em) => false
comparable(10cm, 3mm) => true

Parameters:

Returns:

Raises:

  • (ArgumentError) —

    if either parameter is the wrong type



1590
1591
1592
1593
1594
 
# File 'lib/sass/script/functions.rb', line 1590

def comparable(number1, number2)
  assert_type number1, :Number, :number1
  assert_type number2, :Number, :number2
  bool(number1.comparable_to?(number2))
end

#complement($color) ⇒ Sass::Script::Value::Color

Returns the complement of a color. This is identical to adjust-hue(color, 180deg).

Parameters:

Returns:

Raises:

  • (ArgumentError) —

    if $color isn’t a color

See Also:



1299
1300
1301
 
# File 'lib/sass/script/functions.rb', line 1299

def complement(color)
  adjust_hue color, number(180)
end

#counter($args...) ⇒ String

This function only exists as a workaround for IE7’s content: counter bug. It works identically to any other plain-CSS function, except it avoids adding spaces between the argument commas.

Examples:

counter(item, ".") => counter(item,".")

Returns:

  • (String) 


2119
2120
2121
 
# File 'lib/sass/script/functions.rb', line 2119

def counter(*args)
  identifier("counter(#{args.map {|a| a.to_s(options)}.join(',')})")
end

#counters($args...) ⇒ String

This function only exists as a workaround for IE7’s content: counters bug. It works identically to any other plain-CSS function, except it avoids adding spaces between the argument commas.

Examples:

counters(item, ".") => counters(item,".")

Returns:

  • (String) 


2134
2135
2136
 
# File 'lib/sass/script/functions.rb', line 2134

def counters(*args)
  identifier("counters(#{args.map {|a| a.to_s(options)}.join(',')})")
end

#darken($color, $amount) ⇒ Sass::Script::Value::Color

Makes a color darker. Takes a color and a number between 0% and 100%, and returns a color with the lightness decreased by that amount.

Examples:

darken(hsl(25, 100%, 80%), 30%) => hsl(25, 100%, 50%)
darken(#800, 20%) => #200

Parameters:

Returns:

Raises:

  • (ArgumentError) —

    if $amount is out of bounds, or either parameter is the wrong type

See Also:



930
931
932
 
# File 'lib/sass/script/functions.rb', line 930

def darken(color, amount)
  _adjust(color, amount, :lightness, 0..100, :-, "%")
end

#desaturate($color, $amount) ⇒ Sass::Script::Value::Color

Makes a color less saturated. Takes a color and a number between 0% and 100%, and returns a color with the saturation decreased by that value.

Examples:

desaturate(hsl(120, 30%, 90%), 20%) => hsl(120, 10%, 90%)
desaturate(#855, 20%) => #726b6b

Parameters:

Returns:

Raises:

  • (ArgumentError) —

    if $amount is out of bounds, or either parameter is the wrong type

See Also:



972
973
974
 
# File 'lib/sass/script/functions.rb', line 972

def desaturate(color, amount)
  _adjust(color, amount, :saturation, 0..100, :-, "%")
end

#feature_exists($feature) ⇒ Sass::Script::Value::Bool

Returns whether a feature exists in the current Sass runtime.

Examples:

feature-exists(some-feature-that-exists) => true
feature-exists(what-is-this-i-dont-know) => false

Parameters:

Returns:

Raises:

  • (ArgumentError) —

    if $feature isn’t a string



1538
1539
1540
1541
 
# File 'lib/sass/script/functions.rb', line 1538

def feature_exists(feature)
  assert_type feature, :String, :feature
  bool(Sass.has_feature?(feature.value))
end

#floor($number) ⇒ Sass::Script::Value::Number

Rounds a number down to the previous whole number.

Examples:

floor(10.4px) => 10px
floor(10.6px) => 10px

Parameters:

Returns:

Raises:

  • (ArgumentError) —

    if $number isn’t a number



1651
1652
1653
 
# File 'lib/sass/script/functions.rb', line 1651

def floor(number)
  numeric_transformation(number) {|n| n.floor}
end

#function_exists(name) ⇒ Sass::Script::Bool

Check whether a function with the given name exists.

Examples:

function-exists(lighten) => true

@function myfunc { @return "something"; }
function-exists(myfunc) => true

Parameters:

  • name (Sass::Script::String) —

    The name of the function to check.

Returns:

  • (Sass::Script::Bool) —

    Whether the function is defined.



2188
2189
2190
2191
2192
2193
 
# File 'lib/sass/script/functions.rb', line 2188

def function_exists(name)
  assert_type name, :String, :name
  exists = Sass::Script::Functions.callable?(name.value.tr("-", "_"))
  exists ||= environment.function(name.value)
  bool(exists)
end

#global_variable_exists(name) ⇒ Sass::Script::Bool

Check whether a variable with the given name exists in the global scope (at the top level of the file).

Examples:

$a-false-value: false;
global-variable-exists(a-false-value) => true

.foo {
  $some-var: false;
  @if global-variable-exists(some-var) { /* false, doesn't run */ }
}

Parameters:

  • name (Sass::Script::String) —

    The name of the variable to check. The name should not include the $.

Returns:

  • (Sass::Script::Bool) —

    Whether the variable is defined in the global scope.



2172
2173
2174
2175
 
# File 'lib/sass/script/functions.rb', line 2172

def global_variable_exists(name)
  assert_type name, :String, :name
  bool(environment.global_env.var(name.value))
end

#grayscale($color) ⇒ Sass::Script::Value::Color

Converts a color to grayscale. This is identical to desaturate(color, 100%).

Parameters:

Returns:

Raises:

  • (ArgumentError) —

    if $color isn’t a color

See Also:



1283
1284
1285
1286
1287
1288
 
# File 'lib/sass/script/functions.rb', line 1283

def grayscale(color)
  if color.is_a?(Sass::Script::Value::Number)
    return identifier("grayscale(#{color})")
  end
  desaturate color, number(100)
end

#green($color) ⇒ Sass::Script::Value::Number

Gets the green component of a color. Calculated from HSL where necessary via this algorithm.

Parameters:

Returns:

Raises:

  • (ArgumentError) —

    if $color isn’t a color



735
736
737
738
 
# File 'lib/sass/script/functions.rb', line 735

def green(color)
  assert_type color, :Color, :color
  number(color.green)
end

#hsl($hue, $saturation, $lightness) ⇒ Sass::Script::Value::Color

Creates a Color from hue, saturation, and lightness values. Uses the algorithm from the CSS3 spec.

Parameters:

Returns:

Raises:

  • (ArgumentError) —

    if $saturation or $lightness are out of bounds or any parameter is the wrong type

See Also:



668
669
670
 
# File 'lib/sass/script/functions.rb', line 668

def hsl(hue, saturation, lightness)
  hsla(hue, saturation, lightness, number(1))
end

#hsla($hue, $saturation, $lightness, $alpha) ⇒ Sass::Script::Value::Color

Creates a Color from hue, saturation, lightness, and alpha values. Uses the algorithm from the CSS3 spec.

Parameters:

Returns:

Raises:

  • (ArgumentError) —

    if $saturation, $lightness, or $alpha are out of bounds or any parameter is the wrong type

See Also:



692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
 
# File 'lib/sass/script/functions.rb', line 692

def hsla(hue, saturation, lightness, alpha)
  assert_type hue, :Number, :hue
  assert_type saturation, :Number, :saturation
  assert_type lightness, :Number, :lightness
  assert_type alpha, :Number, :alpha

  Sass::Util.check_range('Alpha channel', 0..1, alpha)

  h = hue.value
  s = Sass::Util.check_range('Saturation', 0..100, saturation, '%')
  l = Sass::Util.check_range('Lightness', 0..100, lightness, '%')

  Sass::Script::Value::Color.new(
    :hue => h, :saturation => s, :lightness => l, :alpha => alpha.value)
end

#hue($color) ⇒ Sass::Script::Value::Number

Returns the hue component of a color. See the CSS3 HSL specification. Calculated from RGB where necessary via this algorithm.

Parameters:

Returns:

Raises:

  • (ArgumentError) —

    if $color isn’t a color



769
770
771
772
 
# File 'lib/sass/script/functions.rb', line 769

def hue(color)
  assert_type color, :Color, :color
  number(color.hue, "deg")
end

#ie_hex_str($color) ⇒ Sass::Script::Value::String

Converts a color into the format understood by IE filters.

Examples:

ie-hex-str(#abc) => #FFAABBCC
ie-hex-str(#3322BB) => #FF3322BB
ie-hex-str(rgba(0, 255, 0, 0.5)) => #8000FF00

Parameters:

Returns:

Raises:

  • (ArgumentError) —

    if $color isn’t a color



1009
1010
1011
1012
1013
 
# File 'lib/sass/script/functions.rb', line 1009

def ie_hex_str(color)
  assert_type color, :Color, :color
  alpha = (color.alpha * 255).round.to_s(16).rjust(2, '0')
  identifier("##{alpha}#{color.send(:hex_str)[1..-1]}".upcase)
end

#if($condition, $if-true, $if-false) ⇒ Sass::Script::Value::Base

Returns one of two values, depending on whether or not $condition is true. Just like in @if, all values other than false and null are considered to be true.

Examples:

if(true, 1px, 2px) => 1px
if(false, 1px, 2px) => 2px

Parameters:

Returns:



2056
2057
2058
2059
2060
2061
2062
 
# File 'lib/sass/script/functions.rb', line 2056

def if(condition, if_true, if_false)
  if condition.to_bool
    perform(if_true)
  else
    perform(if_false)
  end
end

#index($list, $value) ⇒ Sass::Script::Value::Number, Sass::Script::Value::Null

Returns the position of a value within a list. If the value isn’t found, returns null instead.

Note that unlike some languages, the first item in a Sass list is number 1, the second number 2, and so forth.

This can return the position of a pair in a map as well.

Examples:

index(1px solid red, solid) => 2
index(1px solid red, dashed) => null
index((width: 10px, height: 20px), (height 20px)) => 2

Parameters:

Returns:



1894
1895
1896
1897
1898
 
# File 'lib/sass/script/functions.rb', line 1894

def index(list, value)
  index = list.to_a.index {|e| e.eq(value).to_bool}
  return number(index + 1) if index
  Sass::Script::Value::DeprecatedFalse.new(environment)
end

#inspect(value) ⇒ Sass::Script::Value::String

Return a string containing the value as its Sass representation.

Parameters:

Returns:



2217
2218
2219
 
# File 'lib/sass/script/functions.rb', line 2217

def inspect(value)
  unquoted_string(value.to_sass)
end

#invert($color) ⇒ Sass::Script::Value::Color

Returns the inverse (negative) of a color. The red, green, and blue values are inverted, while the opacity is left alone.

Parameters:

Returns:

Raises:

  • (ArgumentError) —

    if $color isn’t a color



1311
1312
1313
1314
1315
1316
1317
1318
1319
1320
1321
 
# File 'lib/sass/script/functions.rb', line 1311

def invert(color)
  if color.is_a?(Sass::Script::Value::Number)
    return identifier("invert(#{color})")
  end

  assert_type color, :Color, :color
  color.with(
    :red => (255 - color.red),
    :green => (255 - color.green),
    :blue => (255 - color.blue))
end

#join($list1, $list2, $separator: auto) ⇒ Sass::Script::Value::List

Joins together two lists into one.

Unless $separator is passed, if one list is comma-separated and one is space-separated, the first parameter’s separator is used for the resulting list. If both lists have fewer than two items, spaces are used for the resulting list.

Examples:

join(10px 20px, 30px 40px) => 10px 20px 30px 40px
join((blue, red), (#abc, #def)) => blue, red, #abc, #def
join(10px, 20px) => 10px 20px
join(10px, 20px, comma) => 10px, 20px
join((blue, red), (#abc, #def), space) => blue red #abc #def

Parameters:

Returns:



1800
1801
1802
1803
1804
1805
1806
1807
1808
1809
1810
1811
 
# File 'lib/sass/script/functions.rb', line 1800

def join(list1, list2, separator = identifier("auto"))
  assert_type separator, :String, :separator
  unless %w[auto space comma].include?(separator.value)
    raise ArgumentError.new("Separator name must be space, comma, or auto")
  end
  sep = if separator.value == 'auto'
          list1.separator || list2.separator || :space
        else
          separator.value.to_sym
        end
  list(list1.to_a + list2.to_a, sep)
end

#keywords($args) ⇒ Sass::Script::Value::Map

Returns the map of named arguments passed to a function or mixin that takes a variable argument list. The argument names are strings, and they do not contain the leading $.

Examples:

@mixin foo($args...) {
  @debug keywords($args); //=> (arg1: val, arg2: val)
}

@include foo($arg1: val, $arg2: val);

Parameters:

Returns:

Raises:

  • (ArgumentError) —

    if $args isn’t a variable argument list



2037
2038
2039
2040
 
# File 'lib/sass/script/functions.rb', line 2037

def keywords(args)
  assert_type args, :ArgList, :args
  map(Sass::Util.map_keys(args.keywords.as_stored) {|k| Sass::Script::String.new(k)})
end

#length($list) ⇒ Sass::Script::Value::Number

Return the length of a list.

This can return the number of pairs in a map as well.

Examples:

length(10px) => 1
length(10px 20px 30px) => 3
length((width: 10px, height: 20px)) => 2

Parameters:

Returns:



1715
1716
1717
 
# File 'lib/sass/script/functions.rb', line 1715

def length(list)
  number(list.to_a.size)
end

#lighten($color, $amount) ⇒ Sass::Script::Value::Color

Makes a color lighter. Takes a color and a number between 0% and 100%, and returns a color with the lightness increased by that amount.

Examples:

lighten(hsl(0, 0%, 0%), 30%) => hsl(0, 0, 30)
lighten(#800, 20%) => #e00

Parameters:

Returns:

Raises:

  • (ArgumentError) —

    if $amount is out of bounds, or either parameter is the wrong type

See Also:



911
912
913
 
# File 'lib/sass/script/functions.rb', line 911

def lighten(color, amount)
  _adjust(color, amount, :lightness, 0..100, :+, "%")
end

#lightness($color) ⇒ Sass::Script::Value::Number

Returns the lightness component of a color. See the CSS3 HSL specification. Calculated from RGB where necessary via this algorithm.

Parameters:

Returns:

Raises:

  • (ArgumentError) —

    if $color isn’t a color



805
806
807
808
 
# File 'lib/sass/script/functions.rb', line 805

def lightness(color)
  assert_type color, :Color, :color
  number(color.lightness, "%")
end

#list_separator($list) ⇒ Sass::Script::Value::String

Returns the separator of a list. If the list doesn’t have a separator due to having fewer than two elements, returns space.

Examples:

list-separator(1px 2px 3px) => space
list-separator(1px, 2px, 3px) => comma
list-separator('foo') => space

Parameters:

Returns:



1911
1912
1913
 
# File 'lib/sass/script/functions.rb', line 1911

def list_separator(list)
  identifier((list.separator || :space).to_s)
end

#map_get($map, $key) ⇒ Sass::Script::Value::Base

Returns the value in a map associated with the given key. If the map doesn’t have such a key, returns null.

Examples:

map-get(("foo": 1, "bar": 2), "foo") => 1
map-get(("foo": 1, "bar": 2), "bar") => 2
map-get(("foo": 1, "bar": 2), "baz") => null

Parameters:

Returns:

Raises:

  • (ArgumentError) —

    if $map is not a map



1929
1930
1931
1932
 
# File 'lib/sass/script/functions.rb', line 1929

def map_get(map, key)
  assert_type map, :Map, :map
  to_h(map)[key] || null
end

#map_has_key($map, $key) ⇒ Sass::Script::Value::Bool

Returns whether a map has a value associated with a given key.

Examples:

map-has-key(("foo": 1, "bar": 2), "foo") => true
map-has-key(("foo": 1, "bar": 2), "baz") => false

Parameters:

Returns:

Raises:

  • (ArgumentError) —

    if $map is not a map



2017
2018
2019
2020
 
# File 'lib/sass/script/functions.rb', line 2017

def map_has_key(map, key)
  assert_type map, :Map, :map
  bool(to_h(map).has_key?(key))
end

#map_keys($map) ⇒ List

Returns a list of all keys in a map.

Examples:

map-keys(("foo": 1, "bar": 2)) => "foo", "bar"

Parameters:

  • $map (Map)

Returns:

  • (List) —

    the list of keys, comma-separated

Raises:

  • (ArgumentError) —

    if $map is not a map



1985
1986
1987
1988
 
# File 'lib/sass/script/functions.rb', line 1985

def map_keys(map)
  assert_type map, :Map, :map
  list(to_h(map).keys, :comma)
end

#map_merge($map1, $map2) ⇒ Sass::Script::Value::Map

Merges two maps together into a new map. Keys in $map2 will take precedence over keys in $map1.

This is the best way to add new values to a map.

All keys in the returned map that also appear in $map1 will have the same order as in $map1. New keys from $map2 will be placed at the end of the map.

Examples:

map-merge(("foo": 1), ("bar": 2)) => ("foo": 1, "bar": 2)
map-merge(("foo": 1, "bar": 2), ("bar": 3)) => ("foo": 1, "bar": 3)

Parameters:

Returns:

Raises:

  • (ArgumentError) —

    if either parameter is not a map



1952
1953
1954
1955
1956
 
# File 'lib/sass/script/functions.rb', line 1952

def map_merge(map1, map2)
  assert_type map1, :Map, :map1
  assert_type map2, :Map, :map2
  map(to_h(map1).merge(to_h(map2)))
end

#map_remove($map, $key) ⇒ Sass::Script::Value::Map

Returns a new map with a key removed.

Examples:

map-remove(("foo": 1, "bar": 2), "bar") => ("foo": 1)
map-remove(("foo": 1, "bar": 2), "baz") => ("foo": 1, "bar": 2)

Parameters:

Returns:

Raises:

  • (ArgumentError) —

    if $map is not a map



1969
1970
1971
1972
1973
1974
 
# File 'lib/sass/script/functions.rb', line 1969

def map_remove(map, key)
  assert_type map, :Map, :map
  hash = to_h(map).dup
  hash.delete key
  map(hash)
end

#map_values($map) ⇒ List

Returns a list of all values in a map. This list may include duplicate values, if multiple keys have the same value.

Examples:

map-values(("foo": 1, "bar": 2)) => 1, 2
map-values(("foo": 1, "bar": 2, "baz": 1)) => 1, 2, 1

Parameters:

  • $map (Map)

Returns:

  • (List) —

    the list of values, comma-separated

Raises:

  • (ArgumentError) —

    if $map is not a map



2001
2002
2003
2004
 
# File 'lib/sass/script/functions.rb', line 2001

def map_values(map)
  assert_type map, :Map, :map
  list(to_h(map).values, :comma)
end

#max($numbers...) ⇒ Sass::Script::Value::Number

Finds the maximum of several numbers. This function takes any number of arguments.

Examples:

max(1px, 4px) => 4px
max(5em, 3em, 4em) => 5em

Parameters:

Returns:

Raises:

  • (ArgumentError) —

    if any argument isn’t a number, or if not all of the arguments have comparable units



1698
1699
1700
1701
 
# File 'lib/sass/script/functions.rb', line 1698

def max(*values)
  values.each {|v| assert_type v, :Number}
  values.inject {|max, val| max.gt(val).to_bool ? max : val}
end

#min($numbers...) ⇒ Sass::Script::Value::Number

Finds the minimum of several numbers. This function takes any number of arguments.

Examples:

min(1px, 4px) => 1px
min(5em, 3em, 4em) => 3em

Parameters:

Returns:

Raises:

  • (ArgumentError) —

    if any argument isn’t a number, or if not all of the arguments have comparable units



1681
1682
1683
1684
 
# File 'lib/sass/script/functions.rb', line 1681

def min(*numbers)
  numbers.each {|n| assert_type n, :Number}
  numbers.inject {|min, num| min.lt(num).to_bool ? min : num}
end

#mix($color1, $color2, $weight: 50%) ⇒ Sass::Script::Value::Color

Mixes two colors together. Specifically, takes the average of each of the RGB components, optionally weighted by the given percentage. The opacity of the colors is also considered when weighting the components.

The weight specifies the amount of the first color that should be included in the returned color. The default, 50%, means that half the first color and half the second color should be used. 25% means that a quarter of the first color and three quarters of the second color should be used.

Examples:

mix(#f00, #00f) => #7f007f
mix(#f00, #00f, 25%) => #3f00bf
mix(rgba(255, 0, 0, 0.5), #00f) => rgba(63, 0, 191, 0.75)

Parameters:

Returns:

Raises:

  • (ArgumentError) —

    if $weight is out of bounds or any parameter is the wrong type



1235
1236
1237
1238
1239
1240
1241
1242
1243
1244
1245
1246
1247
1248
1249
1250
1251
1252
1253
1254
1255
1256
1257
1258
1259
1260
1261
1262
1263
1264
1265
1266
1267
1268
1269
1270
1271
 
# File 'lib/sass/script/functions.rb', line 1235

def mix(color1, color2, weight = number(50))
  assert_type color1, :Color, :color1
  assert_type color2, :Color, :color2
  assert_type weight, :Number, :weight

  Sass::Util.check_range("Weight", 0..100, weight, '%')

  # 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.
  #
  # 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.
  #
  # 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.
  #
  # 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
  w = p * 2 - 1
  a = color1.alpha - color2.alpha

  w1 = ((w * a == -1 ? w : (w + a) / (1 + w * a)) + 1) / 2.0
  w2 = 1 - w1

  rgba = color1.rgb.zip(color2.rgb).map {|v1, v2| v1 * w1 + v2 * w2}
  rgba << color1.alpha * p + color2.alpha * (1 - p)
  rgb_color(*rgba)
end

#mixin_exists(name) ⇒ Sass::Script::Bool

Check whether a mixin with the given name exists.

Examples:

mixin-exists(nonexistent) => false

@mixin red-text { color: red; }
mixin-exists(red-text) => true

Parameters:

  • name (Sass::Script::String) —

    The name of the mixin to check.

Returns:

  • (Sass::Script::Bool) —

    Whether the mixin is defined.



2206
2207
2208
2209
 
# File 'lib/sass/script/functions.rb', line 2206

def mixin_exists(name)
  assert_type name, :String, :name
  bool(environment.mixin(name.value))
end

#nth($list, $n) ⇒ Sass::Script::Value::Base

Gets the nth item in a list.

Note that unlike some languages, the first item in a Sass list is number 1, the second number 2, and so forth.

This can return the nth pair in a map as well.

Negative index values address elements in reverse order, starting with the last element in the list.

Examples:

nth(10px 20px 30px, 1) => 10px
nth((Helvetica, Arial, sans-serif), 3) => sans-serif
nth((width: 10px, length: 20px), 2) => length, 20px

Parameters:

Returns:

Raises:

  • (ArgumentError) —

    if $n isn’t an integer between 1 and the length of $list



1771
1772
1773
1774
1775
1776
1777
 
# File 'lib/sass/script/functions.rb', line 1771

def nth(list, n)
  assert_type n, :Number, :n
  Sass::Script::Value::List.assert_valid_index(list, n)

  index = n.to_i > 0 ? n.to_i - 1 : n.to_i
  list.to_a[index]
end

#opacify($color, $amount) ⇒ Sass::Script::Value::Color Also known as: fade_in

Makes a color more opaque. Takes a color and a number between 0 and 1, and returns a color with the opacity increased by that amount.

Examples:

opacify(rgba(0, 0, 0, 0.5), 0.1) => rgba(0, 0, 0, 0.6)
opacify(rgba(0, 0, 17, 0.8), 0.2) => #001

Parameters:

Returns:

Raises:

  • (ArgumentError) —

    if $amount is out of bounds, or either parameter is the wrong type

See Also:



867
868
869
 
# File 'lib/sass/script/functions.rb', line 867

def opacify(color, amount)
  _adjust(color, amount, :alpha, 0..1, :+)
end

#opacity($color) ⇒ Sass::Script::Value::Number

Returns the alpha component (opacity) of a color. This is 1 unless otherwise specified.

Parameters:

Returns:

Raises:

  • (ArgumentError) —

    if $color isn’t a color



844
845
846
847
848
849
850
 
# File 'lib/sass/script/functions.rb', line 844

def opacity(color)
  if color.is_a?(Sass::Script::Value::Number)
    return identifier("opacity(#{color})")
  end
  assert_type color, :Color, :color
  number(color.alpha)
end

#percentage($number) ⇒ Sass::Script::Value::Number

Converts a unitless number to a percentage.

Examples:

percentage(0.2) => 20%
percentage(100px / 50px) => 200%

Parameters:

Returns:

Raises:

  • (ArgumentError) —

    if $number isn’t a unitless number



1606
1607
1608
1609
1610
1611
 
# File 'lib/sass/script/functions.rb', line 1606

def percentage(number)
  unless number.is_a?(Sass::Script::Value::Number) && number.unitless?
    raise ArgumentError.new("$number: #{number.inspect} is not a unitless number")
  end
  number(number.value * 100, '%')
end

#quote($string) ⇒ Sass::Script::Value::String

Add quotes to a string if the string isn’t quoted, or returns the same string if it is.

Examples:

quote("foo") => "foo"
quote(foo) => "foo"

Parameters:

Returns:

Raises:

  • (ArgumentError) —

    if $string isn’t a string

See Also:



1355
1356
1357
1358
1359
1360
1361
1362
 
# File 'lib/sass/script/functions.rb', line 1355

def quote(string)
  assert_type string, :String, :string
  if string.type != :string
    quoted_string(string.value)
  else
    string
  end
end

#random ⇒ Sass::Script::Number #random($limit) ⇒ Sass::Script::Number

Overloads:

  • #random ⇒ Sass::Script::Number

    Return a decimal between 0 and 1, inclusive of 0 but not 1.

    Returns:

    • (Sass::Script::Number) —

      A decimal value.

  • #random($limit) ⇒ Sass::Script::Number

    Return an integer between 1 and $limit, inclusive of 1 but not $limit.

    Parameters:

    Returns:

    • (Sass::Script::Number) —

      An integer.

    Raises:

    • (ArgumentError) —

      if the $limit is not 1 or greater



2231
2232
2233
2234
2235
2236
2237
2238
2239
2240
2241
2242
 
# File 'lib/sass/script/functions.rb', line 2231

def random(limit = nil)
  generator = Sass::Script::Functions.random_number_generator
  if limit
    assert_integer limit, "limit"
    if limit.value < 1
      raise ArgumentError.new("$limit #{limit} must be greater than or equal to 1")
    end
    number(1 + generator.rand(limit.value))
  else
    number(generator.rand)
  end
end

#red($color) ⇒ Sass::Script::Value::Number

Gets the red component of a color. Calculated from HSL where necessary via this algorithm.

Parameters:

Returns:

Raises:

  • (ArgumentError) —

    if $color isn’t a color



719
720
721
722
 
# File 'lib/sass/script/functions.rb', line 719

def red(color)
  assert_type color, :Color, :color
  number(color.red)
end

#rgb($red, $green, $blue) ⇒ Sass::Script::Value::Color

Creates a Color object from red, green, and blue values.

Parameters:

  • $red (Sass::Script::Value::Number) —

    The amount of red in the color. Must be between 0 and 255 inclusive, or between 0% and 100% inclusive

  • $green (Sass::Script::Value::Number) —

    The amount of green in the color. Must be between 0 and 255 inclusive, or between 0% and 100% inclusive

  • $blue (Sass::Script::Value::Number) —

    The amount of blue in the color. Must be between 0 and 255 inclusive, or between 0% and 100% inclusive

Returns:

Raises:

  • (ArgumentError) —

    if any parameter is the wrong type or out of bounds

See Also:



582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
 
# File 'lib/sass/script/functions.rb', line 582

def rgb(red, green, blue)
  assert_type red, :Number, :red
  assert_type green, :Number, :green
  assert_type blue, :Number, :blue

  color_attrs = [[red, :red], [green, :green], [blue, :blue]].map do |(c, name)|
    if c.is_unit?("%")
      v = Sass::Util.check_range("$#{name}: Color value", 0..100, c, '%')
      v * 255 / 100.0
    elsif c.unitless?
      Sass::Util.check_range("$#{name}: Color value", 0..255, c)
    else
      raise ArgumentError.new("Expected #{c} to be unitless or have a unit of % but got #{c}")
    end
  end
  Sass::Script::Value::Color.new(color_attrs)
end

#rgba($red, $green, $blue, $alpha) ⇒ Sass::Script::Value::Color #rgba($color, $alpha) ⇒ Sass::Script::Value::Color

Creates a Color from red, green, blue, and alpha values.

Overloads:

See Also:



632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
 
# File 'lib/sass/script/functions.rb', line 632

def rgba(*args)
  case args.size
  when 2
    color, alpha = args

    assert_type color, :Color, :color
    assert_type alpha, :Number, :alpha

    Sass::Util.check_range('Alpha channel', 0..1, alpha)
    color.with(:alpha => alpha.value)
  when 4
    red, green, blue, alpha = args
    rgba(rgb(red, green, blue), alpha)
  else
    raise ArgumentError.new("wrong number of arguments (#{args.size} for 4)")
  end
end

#round($number) ⇒ Sass::Script::Value::Number

Rounds a number to the nearest whole number.

Examples:

round(10.4px) => 10px
round(10.6px) => 11px

Parameters:

Returns:

Raises:

  • (ArgumentError) —

    if $number isn’t a number



1623
1624
1625
 
# File 'lib/sass/script/functions.rb', line 1623

def round(number)
  numeric_transformation(number) {|n| n.round}
end

#saturate($color, $amount) ⇒ Sass::Script::Value::Color

Makes a color more saturated. Takes a color and a number between 0% and 100%, and returns a color with the saturation increased by that amount.

Examples:

saturate(hsl(120, 30%, 90%), 20%) => hsl(120, 50%, 90%)
saturate(#855, 20%) => #9e3f3f

Parameters:

Returns:

Raises:

  • (ArgumentError) —

    if $amount is out of bounds, or either parameter is the wrong type

See Also:



949
950
951
952
953
954
 
# File 'lib/sass/script/functions.rb', line 949

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 identifier("saturate(#{color})") if amount.nil?
  _adjust(color, amount, :saturation, 0..100, :+, "%")
end

#saturation($color) ⇒ Sass::Script::Value::Number

Returns the saturation component of a color. See the CSS3 HSL specification. Calculated from RGB where necessary via this algorithm.

Parameters:

Returns:

Raises:

  • (ArgumentError) —

    if $color isn’t a color



787
788
789
790
 
# File 'lib/sass/script/functions.rb', line 787

def saturation(color)
  assert_type color, :Color, :color
  number(color.saturation, "%")
end

#scale_color($color, [$red], [$green], [$blue], [$saturation], [$lightness], [$alpha]) ⇒ Sass::Script::Value::Color

Fluidly scales one or more properties of a color. Unlike adjust-color, which changes a color’s properties by fixed amounts, 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 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.

Examples:

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)

Parameters:

Returns:

Raises:

  • (ArgumentError) —

    if any parameter is the wrong type or out-of bounds, or if RGB properties and HSL properties are adjusted at the same time



1126
1127
1128
1129
1130
1131
1132
1133
1134
1135
1136
1137
1138
1139
1140
1141
1142
1143
1144
1145
1146
1147
1148
1149
1150
1151
1152
1153
1154
1155
 
# File 'lib/sass/script/functions.rb', line 1126

def scale_color(color, kwargs)
  assert_type color, :Color, :color
  with = Sass::Util.map_hash(
      "red" => 255,
      "green" => 255,
      "blue" => 255,
      "saturation" => 100,
      "lightness" => 100,
      "alpha" => 1
    ) do |name, max|

    val = kwargs.delete(name)
    next unless val
    assert_type val, :Number, name
    assert_unit val, '%', name
    Sass::Util.check_range("$#{name}: Amount", -100..100, val, '%')

    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

#set ⇒ Sass::Script::Value::List

Return a new list, based on the list provided, but with the nth element changed to the value given.

Note that unlike some languages, the first item in a Sass list is number 1, the second number 2, and so forth.

Negative index values address elements in reverse order, starting with the last element in the list.

Examples:

set-nth($list: 10px 20px 30px, $n: 2, $value: -20px) => 10px -20px 30px

Parameters:

Returns:

Raises:

  • (ArgumentError) —

    if $n isn’t an integer between 1 and the length of $list



1740
1741
1742
1743
1744
1745
1746
1747
 
# File 'lib/sass/script/functions.rb', line 1740

def set_nth(list, n, value)
  assert_type n, :Number, :n
  Sass::Script::Value::List.assert_valid_index(list, n)
  index = n.to_i > 0 ? n.to_i - 1 : n.to_i
  new_list = list.to_a.dup
  new_list[index] = value
  Sass::Script::Value::List.new(new_list, list.separator)
end

#str_index($string, $substring) ⇒ Sass::Script::Value::Number, Sass::Script::Value::Null

Returns the index of the first occurrence of $substring in $string. If there is no such occurrence, returns null.

Note that unlike some languages, the first character in a Sass string is number 1, the second number 2, and so forth.

Examples:

str-index(abcd, a)  => 1
str-index(abcd, ab) => 1
str-index(abcd, X)  => null
str-index(abcd, c)  => 3

Parameters:

Returns:

Raises:

  • (ArgumentError) —

    if any parameter is the wrong type



1431
1432
1433
1434
1435
1436
 
# File 'lib/sass/script/functions.rb', line 1431

def str_index(string, substring)
  assert_type string, :String, :string
  assert_type substring, :String, :substring
  index = string.value.index(substring.value)
  index ? number(index + 1) : null
end

#str_insert($string, $insert, $index) ⇒ Sass::Script::Value::String

Inserts $insert into $string at $index.

Note that unlike some languages, the first character in a Sass string is number 1, the second number 2, and so forth.

Examples:

str-insert("abcd", "X", 1) => "Xabcd"
str-insert("abcd", "X", 4) => "abcXd"
str-insert("abcd", "X", 5) => "abcdX"

Parameters:

Returns:

Raises:

  • (ArgumentError) —

    if any parameter is the wrong type



1399
1400
1401
1402
1403
1404
1405
1406
1407
1408
1409
1410
1411
 
# File 'lib/sass/script/functions.rb', line 1399

def str_insert(original, insert, index)
  assert_type original, :String, :string
  assert_type insert, :String, :insert
  assert_integer index, :index
  assert_unit index, nil, :index
  insertion_point = if index.value > 0
                      [index.value - 1, original.value.size].min
                    else
                      [index.value, -original.value.size - 1].max
                    end
  result = original.value.dup.insert(insertion_point, insert.value)
  Sass::Script::Value::String.new(result, original.type)
end

#str_length($string) ⇒ Sass::Script::Value::Number

Returns the number of characters in a string.

Examples:

str-length("foo") => 3

Parameters:

Returns:

Raises:

  • (ArgumentError) —

    if $string isn’t a string



1373
1374
1375
1376
 
# File 'lib/sass/script/functions.rb', line 1373

def str_length(string)
  assert_type string, :String, :string
  number(string.value.size)
end

#str_slice($string, $start-at, $end-at: -1) ⇒ Sass::Script::Value::String

Extracts a substring from $string. The substring will begin at index $start-at and ends at index $end-at.

Note that unlike some languages, the first character in a Sass string is number 1, the second number 2, and so forth.

Examples:

str-slice("abcd", 2, 3)   => "bc"
str-slice("abcd", 2)      => "bcd"
str-slice("abcd", -3, -2) => "bc"
str-slice("abcd", 2, -2)  => "bc"

Returns The substring. This will be quoted if and only if $string was quoted.

Parameters:

  • $start-at (Sass::Script::Value::Number) —

    The index of the first character of the substring. If this is negative, it counts from the end of $string

  • $end-before (Sass::Script::Value::Number) —

    The index of the last character of the substring. If this is negative, it counts from the end of $string. Defaults to -1

Returns:

Raises:

  • (ArgumentError) —

    if any parameter is the wrong type



1461
1462
1463
1464
1465
1466
1467
1468
1469
1470
1471
1472
1473
1474
1475
1476
 
# File 'lib/sass/script/functions.rb', line 1461

def str_slice(string, start_at, end_at = nil)
  assert_type string, :String, :string
  assert_unit start_at, nil, "start-at"

  end_at = number(-1) if end_at.nil?
  assert_unit end_at, nil, "end-at"

  s = start_at.value > 0 ? start_at.value - 1 : start_at.value
  e = end_at.value > 0 ? end_at.value - 1 : end_at.value
  s = string.value.length + s if s < 0
  s = 0 if s < 0
  e = string.value.length + e if e < 0
  e = 0 if s < 0
  extracted = string.value.slice(s..e)
  Sass::Script::Value::String.new(extracted || "", string.type)
end

#to_lower_case($string) ⇒ Sass::Script::Value::String

Convert a string to lower case,

Examples:

to-lower-case(ABCD) => abcd

Parameters:

Returns:

Raises:

  • (ArgumentError) —

    if $string isn’t a string



1504
1505
1506
1507
 
# File 'lib/sass/script/functions.rb', line 1504

def to_lower_case(string)
  assert_type string, :String, :string
  Sass::Script::Value::String.new(string.value.downcase, string.type)
end

#to_upper_case($string) ⇒ Sass::Script::Value::String

Converts a string to upper case.

Examples:

to-upper-case(abcd) => ABCD

Parameters:

Returns:

Raises:

  • (ArgumentError) —

    if $string isn’t a string



1489
1490
1491
1492
 
# File 'lib/sass/script/functions.rb', line 1489

def to_upper_case(string)
  assert_type string, :String, :string
  Sass::Script::Value::String.new(string.value.upcase, string.type)
end

#transparentize($color, $amount) ⇒ Sass::Script::Value::Color Also known as: fade_out

Makes a color more transparent. Takes a color and a number between 0 and 1, and returns a color with the opacity decreased by that amount.

Examples:

transparentize(rgba(0, 0, 0, 0.5), 0.1) => rgba(0, 0, 0, 0.4)
transparentize(rgba(0, 0, 0, 0.8), 0.2) => rgba(0, 0, 0, 0.6)

Parameters:

Returns:

Raises:

  • (ArgumentError) —

    if $amount is out of bounds, or either parameter is the wrong type

See Also:



889
890
891
 
# File 'lib/sass/script/functions.rb', line 889

def transparentize(color, amount)
  _adjust(color, amount, :alpha, 0..1, :-)
end

#type_of($value) ⇒ Sass::Script::Value::String

Returns the type of a value.

Examples:

type-of(100px)  => number
type-of(asdf)   => string
type-of("asdf") => string
type-of(true)   => bool
type-of(#fff)   => color
type-of(blue)   => color

Parameters:

Returns:



1523
1524
1525
 
# File 'lib/sass/script/functions.rb', line 1523

def type_of(value)
  identifier(value.class.name.gsub(/Sass::Script::Value::/, '').downcase)
end

#unique_id ⇒ Sass::Script::Value::String

Returns a unique CSS identifier. The identifier is returned as an unquoted string. The identifier returned is only guaranteed to be unique within the scope of a single Sass run.

Returns:



2071
2072
2073
2074
2075
2076
2077
2078
 
# File 'lib/sass/script/functions.rb', line 2071

def unique_id
  generator = Sass::Script::Functions.random_number_generator
  Thread.current[:sass_last_unique_id] ||= generator.rand(36**8)
  # avoid the temptation of trying to guess the next unique value.
  value = (Thread.current[:sass_last_unique_id] += (generator.rand(10) + 1))
  # the u makes this a legal identifier if it would otherwise start with a number.
  identifier("u" + value.to_s(36).rjust(8, '0'))
end

#unit($number) ⇒ Sass::Script::Value::String

Returns the unit(s) associated with a number. Complex units are sorted in alphabetical order by numerator and denominator.

Examples:

unit(100) => ""
unit(100px) => "px"
unit(3em) => "em"
unit(10px * 5em) => "em*px"
unit(10px * 5em / 30cm / 1rem) => "em*px/cm*rem"

Parameters:

Returns:

Raises:

  • (ArgumentError) —

    if $number isn’t a number



1558
1559
1560
1561
 
# File 'lib/sass/script/functions.rb', line 1558

def unit(number)
  assert_type number, :Number, :number
  quoted_string(number.unit_str)
end

#unitless($number) ⇒ Sass::Script::Value::Bool

Returns whether a number has units.

Examples:

unitless(100) => true
unitless(100px) => false

Parameters:

Returns:

Raises:

  • (ArgumentError) —

    if $number isn’t a number



1573
1574
1575
1576
 
# File 'lib/sass/script/functions.rb', line 1573

def unitless(number)
  assert_type number, :Number, :number
  bool(number.unitless?)
end

#unquote($string) ⇒ Sass::Script::Value::String

Removes quotes from a string. If the string is already unquoted, this will return it unmodified.

Examples:

unquote("foo") => foo
unquote(foo) => foo

Parameters:

Returns:

Raises:

  • (ArgumentError) —

    if $string isn’t a string

See Also:



1335
1336
1337
1338
1339
1340
1341
 
# File 'lib/sass/script/functions.rb', line 1335

def unquote(string)
  if string.is_a?(Sass::Script::Value::String) && string.type != :identifier
    identifier(string.value)
  else
    string
  end
end

#variable_exists(name) ⇒ Sass::Script::Bool

Check whether a variable with the given name exists in the current scope or in the global scope.

Examples:

$a-false-value: false;
variable-exists(a-false-value) => true

variable-exists(nonexistent) => false

Parameters:

  • name (Sass::Script::String) —

    The name of the variable to check. The name should not include the $.

Returns:

  • (Sass::Script::Bool) —

    Whether the variable is defined in the current scope.



2151
2152
2153
2154
 
# File 'lib/sass/script/functions.rb', line 2151

def variable_exists(name)
  assert_type name, :String, :name
  bool(environment.caller.var(name.value))
end

#zip($lists...) ⇒ Sass::Script::Value::List

Combines several lists into a single multidimensional list. The nth value of the resulting list is a space separated list of the source lists’ nth values.

The length of the resulting list is the length of the shortest list.

Examples:

zip(1px 1px 3px, solid dashed solid, red green blue)
=> 1px solid red, 1px dashed green, 3px solid blue

Parameters:

Returns:



1861
1862
1863
1864
1865
1866
1867
1868
1869
1870
1871
1872
1873
1874
 
# File 'lib/sass/script/functions.rb', line 1861

def zip(*lists)
  length = nil
  values = []
  lists.each do |list|
    array = list.to_a
    values << array.dup
    length = length.nil? ? array.length : [length, array.length].min
  end
  values.each do |value|
    value.slice!(length)
  end
  new_list_value = values.first.zip(*values[1..-1])
  list(new_list_value.map {|list| list(list, :space)}, :comma)
end