Module Sass::Script::Functions
In: lib/sass/script/functions.rb

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

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

and it will call {Sass::Script::Functions#hsl}.

The following functions are provided:

## RGB Functions

\{rgb} : Converts an `rgb(red, green, blue)` triplet into a color.

\{rgba} : Converts an `rgba(red, green, blue, alpha)` quadruplet into a color.

\{red} : Gets the red component of a color.

\{green} : Gets the green component of a color.

\{blue} : Gets the blue component of a color.

\{mix} : Mixes two colors together.

## HSL Functions

\{hsl} : Converts an `hsl(hue, saturation, lightness)` triplet into a color.

\{hsla} : Converts an `hsla(hue, saturation, lightness, alpha)` quadruplet into a color.

\{hue} : Gets the hue component of a color.

\{saturation} : Gets the saturation component of a color.

\{lightness} : Gets the lightness component of a color.

\{adjust_hue adjust-hue} : Changes the hue of a color.

\{lighten} : Makes a color lighter.

\{darken} : Makes a color darker.

\{saturate} : Makes a color more saturated.

\{desaturate} : Makes a color less saturated.

\{grayscale} : Converts a color to grayscale.

\{complement} : Returns the complement of a color.

## Opacity Functions

\{alpha} / \{opacity} : Gets the alpha component (opacity) of a color.

\{rgba} : Sets the alpha component of a color.

\{opacify} / \{fade_in fade-in} : Makes a color more opaque.

\{transparentize} / \{fade_out fade-out} : Makes a color more transparent.

## String Functions

\{unquote} : Removes the quotes from a string.

\{quote} : Adds quotes to a string.

## Number Functions

\{percentage} : Converts a unitless number to a percentage.

\{round} : Rounds a number to the nearest whole number.

\{ceil} : Rounds a number up to the nearest whole number.

\{floor} : Rounds a number down to the nearest whole number.

\{abs} : Returns the absolute value of a number.

## Introspection Functions

\{type_of} : Returns the type of a value.

\{unit} : Returns the units associated with a number.

\{unitless} : Returns whether a number has units or not.

\{comparable} : Returns whether two numbers can be added or compared.

These functions are described in more detail below.

## 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::String.new(string.value.reverse)
      end
    end

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

Most Literal objects support the {Sass::Script::Literal#value value} accessor for getting their Ruby values. Color objects, though, must be accessed using {Sass::Script::Color#rgb rgb}, {Sass::Script::Color#red red}, {Sass::Script::Color#blue green}, or {Sass::Script::Color#blue 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 {Sass::Engine} to render the code, using the {file:SASS_REFERENCE.md#custom-option `options` parameter} to pass in data that {EvaluationContext#options 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 {Literal} objects within functions, be aware that it‘s not safe to call {Literal#to_s to_s} (or other methods that use the string representation) on those objects without first setting {Node#options= the options attribute}.

Methods

abs   adjust_hue   alpha   blue   ceil   comparable   complement   darken   desaturate   fade_in   fade_out   floor   grayscale   green   hsl   hsla   hue   lighten   lightness   mix   opacify   opacity   percentage   quote   red   rgb   rgba   round   saturate   saturation   transparentize   type_of   unit   unitless   unquote  

Classes and Modules

Class Sass::Script::Functions::EvaluationContext

Public Instance methods

Finds the absolute value of a number. For example:

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

@param value [Number] The number @return [Number] The absolute value @raise [Sass::SyntaxError] if `value` isn‘t a number

[Source]

     # File lib/sass/script/functions.rb, line 833
833:     def abs(value)
834:       numeric_transformation(value) {|n| n.abs}
835:     end

Changes the hue of a color while retaining the lightness and saturation. Takes a color and a number of degrees (usually between -360deg and 360deg), and returns a color with the hue rotated by that value.

For example:

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

@param color [Color] @param amount [Number] @return [Color] @raise [ArgumentError] If `color` isn‘t a color, or `number` isn‘t a number

[Source]

     # File lib/sass/script/functions.rb, line 581
581:     def adjust_hue(color, degrees)
582:       assert_type color, :Color
583:       assert_type degrees, :Number
584:       color.with(:hue => color.hue + degrees.value)
585:     end

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.

@overload def alpha(color) @param color [Color] @return [Number] @see opacify @see transparentize @raise [ArgumentError] If `color` isn‘t a color

[Source]

     # File lib/sass/script/functions.rb, line 426
426:     def alpha(*args)
427:       if args.all? do |a|
428:           a.is_a?(Sass::Script::String) && a.type == :identifier &&
429:             a.value =~ /^[a-zA-Z]+\s*=/
430:         end
431:         # Support the proprietary MS alpha() function
432:         return Sass::Script::String.new("alpha(#{args.map {|a| a.to_s}.join(", ")})")
433:       end
434: 
435:       opacity(*args)
436:     end

Returns the blue component of a color.

@param color [Color] @return [Number] @raise [ArgumentError] If `color` isn‘t a color

[Source]

     # File lib/sass/script/functions.rb, line 362
362:     def blue(color)
363:       assert_type color, :Color
364:       Sass::Script::Number.new(color.blue)
365:     end

Rounds a number up to the nearest whole number. For example:

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

@param value [Number] The number @return [Number] The rounded number @raise [Sass::SyntaxError] if `value` isn‘t a number

[Source]

     # File lib/sass/script/functions.rb, line 807
807:     def ceil(value)
808:       numeric_transformation(value) {|n| n.ceil}
809:     end

Returns true if two numbers are similar enough to be added, subtracted, or compared. For example:

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

@param number1 [Number] @param number2 [Number] @return [Bool] indicating if the numbers can be compared. @raise [ArgumentError] if `number1` or `number2` aren‘t numbers

[Source]

     # File lib/sass/script/functions.rb, line 764
764:     def comparable(number1, number2)
765:       assert_type number1, :Number
766:       assert_type number2, :Number
767:       Sass::Script::Bool.new(number1.comparable_to?(number2))
768:     end

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

@param color [Color] @return [Color] @raise [ArgumentError] if `color` isn‘t a color @see adjust_hue adjust-hue

[Source]

     # File lib/sass/script/functions.rb, line 671
671:     def complement(color)
672:       adjust_hue color, Number.new(180)
673:     end

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

For example:

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

@param color [Color] @param amount [Number] @return [Color] @see lighten @raise [ArgumentError] If `color` isn‘t a color,

  or `number` isn't a number between 0% and 100%

[Source]

     # File lib/sass/script/functions.rb, line 525
525:     def darken(color, amount)
526:       adjust(color, amount, :lightness, 0..100, :-, "%")
527:     end

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

For example:

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

@param color [Color] @param amount [Number] @return [Color] @see saturate @raise [ArgumentError] If `color` isn‘t a color,

  or `number` isn't a number between 0% and 100%

[Source]

     # File lib/sass/script/functions.rb, line 563
563:     def desaturate(color, amount)
564:       adjust(color, amount, :saturation, 0..100, :-, "%")
565:     end
fade_in(color, amount)

Alias for opacify

fade_out(color, amount)

Alias for transparentize

Rounds down to the nearest whole number. For example:

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

@param value [Number] The number @return [Number] The rounded number @raise [Sass::SyntaxError] if `value` isn‘t a number

[Source]

     # File lib/sass/script/functions.rb, line 820
820:     def floor(value)
821:       numeric_transformation(value) {|n| n.floor}
822:     end

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

@param color [Color] @return [Color] @raise [ArgumentError] if `color` isn‘t a color @see desaturate

[Source]

     # File lib/sass/script/functions.rb, line 660
660:     def grayscale(color)
661:       desaturate color, Number.new(100)
662:     end

Returns the green component of a color.

@param color [Color] @return [Number] @raise [ArgumentError] If `color` isn‘t a color

[Source]

     # File lib/sass/script/functions.rb, line 352
352:     def green(color)
353:       assert_type color, :Color
354:       Sass::Script::Number.new(color.green)
355:     end

Creates a {Color} object from hue, saturation, and lightness. Uses the algorithm from the [CSS3 spec](www.w3.org/TR/css3-color/#hsl-color).

@param hue [Number] The hue of the color.

  Should be between 0 and 360 degrees, inclusive

@param saturation [Number] The saturation of the color.

  Must be between `0%` and `100%`, inclusive

@param lightness [Number] The lightness of the color.

  Must be between `0%` and `100%`, inclusive

@return [Color] The resulting color @see hsla @raise [ArgumentError] if `saturation` or `lightness` are out of bounds

[Source]

     # File lib/sass/script/functions.rb, line 298
298:     def hsl(hue, saturation, lightness)
299:       hsla(hue, saturation, lightness, Number.new(1))
300:     end

Creates a {Color} object from hue, saturation, and lightness, as well as an alpha channel indicating opacity. Uses the algorithm from the [CSS3 spec](www.w3.org/TR/css3-color/#hsl-color).

@param hue [Number] The hue of the color.

  Should be between 0 and 360 degrees, inclusive

@param saturation [Number] The saturation of the color.

  Must be between `0%` and `100%`, inclusive

@param lightness [Number] The lightness of the color.

  Must be between `0%` and `100%`, inclusive

@param alpha [Number] The opacity of the color.

  Must be between 0 and 1, inclusive

@return [Color] The resulting color @see hsl @raise [ArgumentError] if `saturation`, `lightness`, or `alpha` are out of bounds

[Source]

     # File lib/sass/script/functions.rb, line 317
317:     def hsla(hue, saturation, lightness, alpha)
318:       assert_type hue, :Number
319:       assert_type saturation, :Number
320:       assert_type lightness, :Number
321:       assert_type alpha, :Number
322: 
323:       unless (0..1).include?(alpha.value)
324:         raise ArgumentError.new("Alpha channel #{alpha.value} must be between 0 and 1")
325:       end
326: 
327:       original_s = saturation
328:       original_l = lightness
329:       # This algorithm is from http://www.w3.org/TR/css3-color#hsl-color
330:       h, s, l = [hue, saturation, lightness].map { |a| a.value }
331:       raise ArgumentError.new("Saturation #{s} must be between 0% and 100%") unless (0..100).include?(s)
332:       raise ArgumentError.new("Lightness #{l} must be between 0% and 100%") unless (0..100).include?(l)
333: 
334:       Color.new(:hue => h, :saturation => s, :lightness => l, :alpha => alpha.value)
335:     end

Returns the hue component of a color.

See [the CSS3 HSL specification](en.wikipedia.org/wiki/HSL_and_HSV#Conversion_from_RGB_to_HSL_or_HSV).

Calculated from RGB where necessary via [this algorithm](en.wikipedia.org/wiki/HSL_and_HSV#Conversion_from_RGB_to_HSL_or_HSV).

@param color [Color] @return [Number] between 0deg and 360deg @see adjust_hue @raise [ArgumentError] if `color` isn‘t a color

[Source]

     # File lib/sass/script/functions.rb, line 377
377:     def hue(color)
378:       assert_type color, :Color
379:       Sass::Script::Number.new(color.hue, ["deg"])
380:     end

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

For example:

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

@param color [Color] @param amount [Number] @return [Color] @see darken @raise [ArgumentError] If `color` isn‘t a color,

  or `number` isn't a number between 0% and 100%

[Source]

     # File lib/sass/script/functions.rb, line 506
506:     def lighten(color, amount)
507:       adjust(color, amount, :lightness, 0..100, :+, "%")
508:     end

Returns the hue component of a color.

See [the CSS3 HSL specification](en.wikipedia.org/wiki/HSL_and_HSV#Conversion_from_RGB_to_HSL_or_HSV).

Calculated from RGB where necessary via [this algorithm](en.wikipedia.org/wiki/HSL_and_HSV#Conversion_from_RGB_to_HSL_or_HSV).

@param color [Color] @return [Number] between 0% and 100% @see lighten @see darken @raise [ArgumentError] if `color` isn‘t a color

[Source]

     # File lib/sass/script/functions.rb, line 409
409:     def lightness(color)
410:       assert_type color, :Color
411:       Sass::Script::Number.new(color.lightness, ["%"])
412:     end

Mixes together two colors. 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.

For example:

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

@overload mix(color1, color2, weight = 50%)

  @param color1 [Color]
  @param color2 [Color]
  @param weight [Number] between 0% and 100%
  @return [Color]
  @raise [ArgumentError] if `color1` or `color2` aren't colors,
    or `weight` isn't a number between 0% and 100%

[Source]

     # File lib/sass/script/functions.rb, line 612
612:     def mix(color1, color2, weight = Number.new(50))
613:       assert_type color1, :Color
614:       assert_type color2, :Color
615:       assert_type weight, :Number
616: 
617:       unless (0..100).include?(weight.value)
618:         raise ArgumentError.new("Weight #{weight} must be between 0% and 100%")
619:       end
620: 
621:       # This algorithm factors in both the user-provided weight
622:       # and the difference between the alpha values of the two colors
623:       # to decide how to perform the weighted average of the two RGB values.
624:       #
625:       # It works by first normalizing both parameters to be within [-1, 1],
626:       # where 1 indicates "only use color1", -1 indicates "only use color 0",
627:       # and all values in between indicated a proportionately weighted average.
628:       #
629:       # Once we have the normalized variables w and a,
630:       # we apply the formula (w + a)/(1 + w*a)
631:       # to get the combined weight (in [-1, 1]) of color1.
632:       # This formula has two especially nice properties:
633:       #
634:       #   * When either w or a are -1 or 1, the combined weight is also that number
635:       #     (cases where w * a == -1 are undefined, and handled as a special case).
636:       #
637:       #   * When a is 0, the combined weight is w, and vice versa
638:       #
639:       # Finally, the weight of color1 is renormalized to be within [0, 1]
640:       # and the weight of color2 is given by 1 minus the weight of color1.
641:       p = weight.value/100.0
642:       w = p*2 - 1
643:       a = color1.alpha - color2.alpha
644: 
645:       w1 = (((w * a == -1) ? w : (w + a)/(1 + w*a)) + 1)/2.0
646:       w2 = 1 - w1
647: 
648:       rgb = color1.rgb.zip(color2.rgb).map {|v1, v2| v1*w1 + v2*w2}
649:       alpha = color1.alpha*p + color2.alpha*(1-p)
650:       Color.new(rgb + [alpha])
651:     end

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

For example:

    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

@param color [Color] @param amount [Number] @return [Color] @see transparentize @raise [ArgumentError] If `color` isn‘t a color,

  or `number` isn't a number between 0 and 1

[Source]

     # File lib/sass/script/functions.rb, line 466
466:     def opacify(color, amount)
467:       adjust(color, amount, :alpha, 0..1, :+)
468:     end

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

@param color [Color] @return [Number] @see opacify @see transparentize @raise [ArgumentError] If `color` isn‘t a color

[Source]

     # File lib/sass/script/functions.rb, line 446
446:     def opacity(color)
447:       assert_type color, :Color
448:       Sass::Script::Number.new(color.alpha)
449:     end

Converts a decimal number to a percentage. For example:

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

@param value [Number] The decimal number to convert to a percentage @return [Number] The percentage @raise [ArgumentError] If `value` isn‘t a unitless number

[Source]

     # File lib/sass/script/functions.rb, line 778
778:     def percentage(value)
779:       unless value.is_a?(Sass::Script::Number) && value.unitless?
780:         raise ArgumentError.new("#{value.inspect} is not a unitless number")
781:       end
782:       Sass::Script::Number.new(value.value * 100, ['%'])
783:     end

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

@param str [String] @return [String] @raise [ArgumentError] if `str` isn‘t a string @see unquote @example quote("foo") => "foo" quote(foo) => "foo"

[Source]

     # File lib/sass/script/functions.rb, line 700
700:     def quote(str)
701:       assert_type str, :String
702:       Sass::Script::String.new(str.value, :string)
703:     end

Returns the red component of a color.

@param color [Color] @return [Number] @raise [ArgumentError] If `color` isn‘t a color

[Source]

     # File lib/sass/script/functions.rb, line 342
342:     def red(color)
343:       assert_type color, :Color
344:       Sass::Script::Number.new(color.red)
345:     end

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

@param red [Number]

  A number between 0 and 255 inclusive,
  or between 0% and 100% inclusive

@param green [Number]

  A number between 0 and 255 inclusive,
  or between 0% and 100% inclusive

@param blue [Number]

  A number between 0 and 255 inclusive,
  or between 0% and 100% inclusive

@see rgba @return [Color]

[Source]

     # File lib/sass/script/functions.rb, line 222
222:     def rgb(red, green, blue)
223:       assert_type red, :Number
224:       assert_type green, :Number
225:       assert_type blue, :Number
226: 
227:       Color.new([red, green, blue].map do |c|
228:           v = c.value
229:           if c.numerator_units == ["%"] && c.denominator_units.empty?
230:             next v * 255 / 100.0 if (0..100).include?(v)
231:             raise ArgumentError.new("Color value #{c} must be between 0% and 100% inclusive")
232:           else
233:             next v if (0..255).include?(v)
234:             raise ArgumentError.new("Color value #{v} must be between 0 and 255 inclusive")
235:           end
236:         end)
237:     end

@see rgb @overload rgba(red, green, blue, alpha)

  Creates a {Color} object from red, green, and blue values,
  as well as an alpha channel indicating opacity.

  @param red [Number]
    A number between 0 and 255 inclusive
  @param green [Number]
    A number between 0 and 255 inclusive
  @param blue [Number]
    A number between 0 and 255 inclusive
  @param alpha [Number]
    A number between 0 and 1
  @return [Color]

@overload rgba(color, alpha)

  Sets the opacity of a color.

  @example
    rgba(#102030, 0.5) => rgba(16, 32, 48, 0.5)
    rgba(blue, 0.2)    => rgba(0, 0, 255, 0.2)

  @param color [Color]
  @param alpha [Number]
    A number between 0 and 1
  @return [Color]

[Source]

     # File lib/sass/script/functions.rb, line 265
265:     def rgba(*args)
266:       case args.size
267:       when 2
268:         color, alpha = args
269: 
270:         assert_type color, :Color
271:         assert_type alpha, :Number
272: 
273:         unless (0..1).include?(alpha.value)
274:           raise ArgumentError.new("Alpha channel #{alpha.value} must be between 0 and 1 inclusive")
275:         end
276: 
277:         color.with(:alpha => alpha.value)
278:       when 4
279:         red, green, blue, alpha = args
280:         rgba(rgb(red, green, blue), alpha)
281:       else
282:         raise ArgumentError.new("wrong number of arguments (#{args.size} for 4)")
283:       end
284:     end

Rounds a number to the nearest whole number. For example:

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

@param value [Number] The number @return [Number] The rounded number @raise [Sass::SyntaxError] if `value` isn‘t a number

[Source]

     # File lib/sass/script/functions.rb, line 794
794:     def round(value)
795:       numeric_transformation(value) {|n| n.round}
796:     end

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

For example:

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

@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%

[Source]

     # File lib/sass/script/functions.rb, line 544
544:     def saturate(color, amount)
545:       adjust(color, amount, :saturation, 0..100, :+, "%")
546:     end

Returns the saturation component of a color.

See [the CSS3 HSL specification](en.wikipedia.org/wiki/HSL_and_HSV#Conversion_from_RGB_to_HSL_or_HSV).

Calculated from RGB where necessary via [this algorithm](en.wikipedia.org/wiki/HSL_and_HSV#Conversion_from_RGB_to_HSL_or_HSV).

@param color [Color] @return [Number] between 0% and 100% @see saturate @see desaturate @raise [ArgumentError] if `color` isn‘t a color

[Source]

     # File lib/sass/script/functions.rb, line 393
393:     def saturation(color)
394:       assert_type color, :Color
395:       Sass::Script::Number.new(color.saturation, ["%"])
396:     end

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

For example:

    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)

@param color [Color] @param amount [Number] @return [Color] @see opacify @raise [ArgumentError] If `color` isn‘t a color,

  or `number` isn't a number between 0 and 1

[Source]

     # File lib/sass/script/functions.rb, line 486
486:     def transparentize(color, amount)
487:       adjust(color, amount, :alpha, 0..1, :-)
488:     end

Inspects the type of the argument, returning it as an unquoted string. For example:

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

@param obj [Literal] The object to inspect @return [String] The unquoted string name of the literal‘s type

[Source]

     # File lib/sass/script/functions.rb, line 717
717:     def type_of(obj)
718:       Sass::Script::String.new(obj.class.name.gsub(/Sass::Script::/,'').downcase)
719:     end

Inspects the unit of the number, returning it as a quoted string. Complex units are sorted in alphabetical order by numerator and denominator. For example:

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

@param number [Literal] The number to inspect @return [String] The unit(s) of the number @raise [ArgumentError] if `number` isn‘t a number

[Source]

     # File lib/sass/script/functions.rb, line 734
734:     def unit(number)
735:       assert_type number, :Number
736:       Sass::Script::String.new(number.unit_str, :string)
737:     end

Inspects the unit of the number, returning a boolean indicating if it is unitless. For example:

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

@param number [Literal] The number to inspect @return [Bool] Whether or not the number is unitless @raise [ArgumentError] if `number` isn‘t a number

[Source]

     # File lib/sass/script/functions.rb, line 748
748:     def unitless(number)
749:       assert_type number, :Number
750:       Sass::Script::Bool.new(number.unitless?)
751:     end

Removes quotes from a string if the string is quoted, or returns the same string if it‘s not.

@param str [String] @return [String] @raise [ArgumentError] if `str` isn‘t a string @see quote @example unquote("foo") => foo unquote(foo) => foo

[Source]

     # File lib/sass/script/functions.rb, line 685
685:     def unquote(str)
686:       assert_type str, :String
687:       Sass::Script::String.new(str.value, :identifier)
688:     end

[Validate]