sass-embedded 0.13.4 → 0.16.1

data/lib/sass/value/argument_list.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Sass
+  class Value
+    # Sass's argument list type.
+    #
+    # An argument list comes from a rest argument. It's distinct from a normal {List} in that it may contain a keyword
+    # map as well as the positional arguments.
+    class ArgumentList < Sass::Value::List
+      def initialize(contents = [], keywords = {}, separator = ',')
+        super(contents, separator: separator)
+
+        @id = 0
+        @keywords_accessed = false
+        @keywords = keywords.transform_keys(&:to_s).freeze
+      end
+
+      def keywords
+        @keywords_accessed = true
+        @keywords
+      end
+    end
+  end
+end

data/lib/sass/value/boolean.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Sass
+  class Value
+    # Sass's boolean type.
+    class Boolean < Sass::Value
+      def initialize(value) # rubocop:disable Lint/MissingSuper
+        @value = value
+      end
+
+      attr_reader :value
+
+      alias to_bool value
+
+      def assert_boolean(_name = nil)
+        self
+      end
+
+      def ==(other)
+        other.is_a?(Sass::Value::Boolean) && other.value == value
+      end
+
+      def hash
+        @hash ||= value.hash
+      end
+
+      def !
+        value ? Boolean::FALSE : Boolean::TRUE
+      end
+
+      # Sass's true value.
+      TRUE = Boolean.new(true)
+
+      # Sass's false value.
+      FALSE = Boolean.new(false)
+
+      def self.new(value)
+        value ? Boolean::TRUE : Boolean::FALSE
+      end
+    end
+  end
+end

data/lib/sass/value/color.rb

@@ -0,0 +1,213 @@
+# frozen_string_literal: true
+
+module Sass
+  class Value
+    # Sass's color type.
+    #
+    # No matter what representation was originally used to create this color, all of its channels are accessible.
+    class Color < Sass::Value
+      def initialize(red: nil, green: nil, blue: nil, # rubocop:disable Lint/MissingSuper
+                     hue: nil, saturation: nil, lightness: nil,
+                     whiteness: nil, blackness: nil,
+                     alpha: nil)
+        @alpha = alpha.nil? ? 1 : FuzzyMath.assert_between(alpha, 0, 1, 'alpha')
+        if red && green && blue
+          @red = FuzzyMath.assert_between(FuzzyMath.round(red), 0, 255, 'red')
+          @green = FuzzyMath.assert_between(FuzzyMath.round(green), 0, 255, 'green')
+          @blue = FuzzyMath.assert_between(FuzzyMath.round(blue), 0, 255, 'blue')
+        elsif hue && saturation && lightness
+          @hue = hue % 360
+          @saturation = FuzzyMath.assert_between(saturation, 0, 100, 'saturation')
+          @lightness = FuzzyMath.assert_between(lightness, 0, 100, 'lightness')
+        elsif hue && whiteness && blackness
+          @hue = hue % 360
+          @whiteness = FuzzyMath.assert_between(whiteness, 0, 100, 'whiteness')
+          @blackness = FuzzyMath.assert_between(blackness, 0, 100, 'blackness')
+          hwb_to_rgb
+          @whiteness = @blackness = nil
+        else
+          raise error 'Invalid Color'
+        end
+      end
+
+      def change(red: nil,
+                 green: nil,
+                 blue: nil,
+                 hue: nil,
+                 saturation: nil,
+                 lightness: nil,
+                 whiteness: nil,
+                 blackness: nil,
+                 alpha: nil)
+        if whiteness || blackness
+          Sass::Value::Color.new(hue: hue || self.hue,
+                                 whiteness: whiteness || self.whiteness,
+                                 blackness: blackness || self.blackness,
+                                 alpha: alpha || self.alpha)
+        elsif hue || saturation || lightness
+          Sass::Value::Color.new(hue: hue || self.hue,
+                                 saturation: saturation || self.saturation,
+                                 lightness: lightness || self.lightness,
+                                 alpha: alpha || self.alpha)
+        elsif red || green || blue
+          Sass::Value::Color.new(red: red ? FuzzyMath.round(red) : self.red,
+                                 green: green ? FuzzyMath.round(green) : self.green,
+                                 blue: blue ? FuzzyMath.round(blue) : self.blue,
+                                 alpha: alpha || self.alpha)
+        else
+          dup.instance_eval do
+            @alpha = FuzzyMath.assert_between(alpha, 0, 1, 'alpha')
+            self
+          end
+        end
+      end
+
+      def red
+        hsl_to_rgb if @red.nil?
+
+        @red
+      end
+
+      def green
+        hsl_to_rgb if @green.nil?
+
+        @green
+      end
+
+      def blue
+        hsl_to_rgb if @blue.nil?
+
+        @blue
+      end
+
+      def hue
+        rgb_to_hsl if @hue.nil?
+
+        @hue
+      end
+
+      def saturation
+        rgb_to_hsl if @saturation.nil?
+
+        @saturation
+      end
+
+      def lightness
+        rgb_to_hsl if @lightness.nil?
+
+        @lightness
+      end
+
+      def whiteness
+        @whiteness ||= Rational([red, green, blue].min, 255) * 100
+      end
+
+      def blackness
+        @blackness ||= 100 - (Rational([red, green, blue].max, 255) * 100)
+      end
+
+      attr_reader :alpha
+
+      def assert_color(_name = nil)
+        self
+      end
+
+      def ==(other)
+        other.is_a?(Sass::Value::Color) &&
+          other.red == red &&
+          other.green == green &&
+          other.blue == blue &&
+          other.alpha == alpha
+      end
+
+      def hash
+        @hash ||= red.hash ^ green.hash ^ blue.hash ^ alpha.hash
+      end
+
+      private
+
+      def rgb_to_hsl
+        scaled_red = Rational(red, 255)
+        scaled_green = Rational(green, 255)
+        scaled_blue = Rational(blue, 255)
+
+        max = [scaled_red, scaled_green, scaled_blue].max
+        min = [scaled_red, scaled_green, scaled_blue].min
+        delta = max - min
+
+        if max == min
+          @hue = 0
+        elsif max == scaled_red
+          @hue = (60 * (scaled_green - scaled_blue) / delta) % 360
+        elsif max == scaled_green
+          @hue = (120 + (60 * (scaled_blue - scaled_red) / delta)) % 360
+        elsif max == scaled_blue
+          @hue = (240 + (60 * (scaled_red - scaled_green) / delta)) % 360
+        end
+
+        lightness = @lightness = 50 * (max + min)
+
+        @saturation = if max == min
+                        0
+                      elsif lightness < 50
+                        100 * delta / (max + min)
+                      else
+                        100 * delta / (2 - max - min)
+                      end
+      end
+
+      def hsl_to_rgb
+        scaled_hue = Rational(hue, 360)
+        scaled_saturation = Rational(saturation, 100)
+        scaled_lightness = Rational(lightness, 100)
+
+        tmp2 = if scaled_lightness <= 0.5
+                 scaled_lightness * (scaled_saturation + 1)
+               else
+                 scaled_lightness + scaled_saturation - (scaled_lightness * scaled_saturation)
+               end
+        tmp1 = (scaled_lightness * 2) - tmp2
+        @red = FuzzyMath.round(hsl_hue_to_rgb(tmp1, tmp2, scaled_hue + Rational(1, 3)) * 255)
+        @green = FuzzyMath.round(hsl_hue_to_rgb(tmp1, tmp2, scaled_hue) * 255)
+        @blue = FuzzyMath.round(hsl_hue_to_rgb(tmp1, tmp2, scaled_hue - Rational(1, 3)) * 255)
+      end
+
+      def hsl_hue_to_rgb(tmp1, tmp2, hue)
+        hue += 1 if hue.negative?
+        hue -= 1 if hue > 1
+
+        if hue < Rational(1, 6)
+          tmp1 + ((tmp2 - tmp1) * hue * 6)
+        elsif hue < Rational(1, 2)
+          tmp2
+        elsif hue < Rational(2, 3)
+          tmp1 + ((tmp2 - tmp1) * (Rational(2, 3) - hue) * 6)
+        else
+          tmp1
+        end
+      end
+
+      def hwb_to_rgb
+        scaled_hue = Rational(hue, 360)
+        scaled_whiteness = Rational(whiteness, 100)
+        scaled_blackness = Rational(blackness, 100)
+
+        sum = scaled_whiteness + scaled_blackness
+        if sum > 1
+          scaled_whiteness /= sum
+          scaled_blackness /= sum
+        end
+
+        factor = 1 - scaled_whiteness - scaled_blackness
+        @red = hwb_hue_to_rgb(factor, scaled_whiteness, scaled_hue + Rational(1, 3))
+        @green = hwb_hue_to_rgb(factor, scaled_whiteness, scaled_hue)
+        @blue = hwb_hue_to_rgb(factor, scaled_whiteness, scaled_hue - Rational(1, 3))
+      end
+
+      def hwb_hue_to_rgb(factor, scaled_whiteness, scaled_hue)
+        channel = (hsl_hue_to_rgb(0, 1, scaled_hue) * factor) + scaled_whiteness
+        FuzzyMath.round(channel * 255)
+      end
+    end
+  end
+end

data/lib/sass/value/function.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Sass
+  class Value
+    # Sass's function type.
+    class Function < Sass::Value
+      def initialize(id_or_signature, callback = nil) # rubocop:disable Lint/MissingSuper
+        if id_or_signature.is_a? Numeric
+          @id = id_or_signature
+        else
+          @signature = id_or_signature
+          @callback = callback
+        end
+      end
+
+      attr_reader :id, :signature, :callback
+
+      def assert_function(_name = nil)
+        self
+      end
+
+      def ==(other)
+        if id.nil?
+          other.equal? self
+        else
+          other.is_a?(Sass::Value::Function) && other.id == id
+        end
+      end
+
+      def hash
+        id.nil? ? signature.hash : id.hash
+      end
+    end
+  end
+end

data/lib/sass/value/fuzzy_math.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+module Sass
+  class Value
+    # Sass's {FuzzyMath} module.
+    module FuzzyMath
+      PRECISION = 10
+
+      EPSILON = 10.pow(-PRECISION - 1)
+
+      INVERSE_EPSILON = 1 / EPSILON
+
+      module_function
+
+      def equals(number1, number2)
+        (number1 - number2).abs < EPSILON
+      end
+
+      def less_than(number1, number2)
+        number1 < number2 && !equals(number1, number2)
+      end
+
+      def less_than_or_equals(number1, number2)
+        number1 < number2 || equals(number1, number2)
+      end
+
+      def greater_than(number1, number2)
+        number1 > number2 && !equals(number1, number2)
+      end
+
+      def greater_than_or_equals(number1, number2)
+        number1 > number2 || equals(number1, number2)
+      end
+
+      def integer?(number)
+        return false unless number.finite?
+        return true if number.integer?
+
+        equals((number - 0.5).abs % 1, 0.5)
+      end
+
+      def to_i(number)
+        integer?(number) ? number.round : nil
+      end
+
+      def round(number)
+        if number.positive?
+          less_than(number % 1, 0.5) ? number.floor : number.ceil
+        else
+          less_than_or_equals(number % 1, 0.5) ? number.floor : number.ceil
+        end
+      end
+
+      def between(number, min, max)
+        return min if equals(number, min)
+        return max if equals(number, max)
+        return number if number > min && number < max
+
+        nil
+      end
+
+      def assert_between(number, min, max, name)
+        result = between(number, min, max)
+        return result unless result.nil?
+
+        message = "#{number} must be between #{min} and #{max}."
+        raise Sass::ScriptError, name.nil? ? message : "$#{name}: #{message}"
+      end
+
+      def hash(number)
+        @hash ||= if number.finite?
+                    (number * INVERSE_EPSILON).round.hash
+                  else
+                    number.hash
+                  end
+      end
+    end
+
+    private_constant :FuzzyMath
+  end
+end

data/lib/sass/value/list.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module Sass
+  class Value
+    # Sass's list type.
+    class List < Sass::Value
+      def initialize(contents = [], separator: ',', bracketed: false) # rubocop:disable Lint/MissingSuper
+        if separator.nil? && contents.length > 1
+          raise error 'A list with more than one element must have an explicit separator'
+        end
+
+        @contents = contents.freeze
+        @separator = separator.freeze
+        @bracketed = bracketed.freeze
+      end
+
+      attr_reader :contents, :separator
+
+      alias to_a contents
+
+      def bracketed?
+        @bracketed
+      end
+
+      def assert_map(name = nil)
+        to_a.empty? ? Sass::Value::Map.new({}) : super.assert_map(name)
+      end
+
+      def to_map
+        to_a.empty? ? Sass::Value::Map.new({}) : nil
+      end
+
+      def at(index)
+        index = index.floor
+        index = to_a.length + index if index.negative?
+        return nil if index.negative? || index >= to_a.length
+
+        to_a[index]
+      end
+
+      def ==(other)
+        (other.is_a?(Sass::Value::List) &&
+         other.contents == contents &&
+         other.separator == separator &&
+         other.bracketed? == bracketed?) ||
+          (to_a.empty? && other.is_a?(Sass::Value::Map) && other.to_a.empty?)
+      end
+
+      def hash
+        @hash ||= contents.hash
+      end
+
+      private
+
+      def to_a_length
+        to_a.length
+      end
+    end
+  end
+end

data/lib/sass/value/map.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module Sass
+  class Value
+    # Sass's map type.
+    class Map < Sass::Value
+      def initialize(contents = {}) # rubocop:disable Lint/MissingSuper
+        @contents = contents.freeze
+      end
+
+      attr_reader :contents
+
+      def separator
+        contents.empty? ? nil : ','
+      end
+
+      def assert_map(_name = nil)
+        self
+      end
+
+      def to_map
+        self
+      end
+
+      def to_a
+        contents.to_a.map { |entry| Sass::Value::List.new(entry, separator: ' ') }
+      end
+
+      def at(index)
+        if index.is_a? Numeric
+          index = index.floor
+          index = to_a.length + index if index.negative?
+          return nil if index.negative? || index >= to_a.length
+
+          to_a[index]
+        else
+          contents[index]
+        end
+      end
+
+      def ==(other)
+        (other.is_a?(Sass::Value::Map) && other.contents == contents) ||
+          (contents.empty? && other.is_a?(Sass::Value::List) && other.to_a.empty?)
+      end
+
+      def hash
+        @hash ||= contents.hash
+      end
+
+      private
+
+      def to_a_length
+        contents.length
+      end
+    end
+  end
+end

data/lib/sass/value/null.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Sass
+  class Value
+    # Sass's null type.
+    class Null < Sass::Value
+      def initialize # rubocop:disable Lint/MissingSuper
+        @value = nil
+      end
+
+      attr_reader :value
+
+      alias to_nil value
+
+      def to_bool
+        false
+      end
+
+      def ==(other)
+        other.is_a?(Sass::Value::Null)
+      end
+
+      def hash
+        @hash ||= value.hash
+      end
+
+      def !
+        Boolean::TRUE
+      end
+
+      # Sass's null value.
+      NULL = Null.new
+
+      def self.new
+        NULL
+      end
+    end
+  end
+end