sass-embedded 0.15.0 → 0.17.0

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

data/lib/sass/value/number/unit.rb

@@ -0,0 +1,186 @@
+# frozen_string_literal: true
+
+module Sass
+  class Value
+    class Number
+      # The {Unit} module.
+      module Unit
+        CONVERSIONS = {
+          # Length
+          'in' => {
+            'in' => Rational(1),
+            'cm' => Rational(1, 2.54),
+            'pc' => Rational(1, 6),
+            'mm' => Rational(1, 25.4),
+            'q' => Rational(1, 101.6),
+            'pt' => Rational(1, 72),
+            'px' => Rational(1, 96)
+          },
+          'cm' => {
+            'in' => Rational(2.54),
+            'cm' => Rational(1),
+            'pc' => Rational(2.54, 6),
+            'mm' => Rational(1, 10),
+            'q' => Rational(1, 40),
+            'pt' => Rational(2.54, 72),
+            'px' => Rational(2.54, 96)
+          },
+          'pc' => {
+            'in' => Rational(6),
+            'cm' => Rational(6, 2.54),
+            'pc' => Rational(1),
+            'mm' => Rational(6, 25.4),
+            'q' => Rational(6, 101.6),
+            'pt' => Rational(1, 12),
+            'px' => Rational(1, 16)
+          },
+          'mm' => {
+            'in' => Rational(25.4),
+            'cm' => Rational(10),
+            'pc' => Rational(25.4, 6),
+            'mm' => Rational(1),
+            'q' => Rational(1, 4),
+            'pt' => Rational(25.4, 72),
+            'px' => Rational(25.4, 96)
+          },
+          'q' => {
+            'in' => Rational(101.6),
+            'cm' => Rational(40),
+            'pc' => Rational(101.6, 6),
+            'mm' => Rational(4),
+            'q' => Rational(1),
+            'pt' => Rational(101.6, 72),
+            'px' => Rational(101.6, 96)
+          },
+          'pt' => {
+            'in' => Rational(72),
+            'cm' => Rational(72, 2.54),
+            'pc' => Rational(12),
+            'mm' => Rational(72, 25.4),
+            'q' => Rational(72, 101.6),
+            'pt' => Rational(1),
+            'px' => Rational(3, 4)
+          },
+          'px' => {
+            'in' => Rational(96),
+            'cm' => Rational(96, 2.54),
+            'pc' => Rational(16),
+            'mm' => Rational(96, 25.4),
+            'q' => Rational(96, 101.6),
+            'pt' => Rational(4, 3),
+            'px' => Rational(1)
+          },
+
+          # Rotation
+          'deg' => {
+            'deg' => Rational(1),
+            'grad' => Rational(9, 10),
+            'rad' => Rational(180, Math::PI),
+            'turn' => Rational(360)
+          },
+          'grad' => {
+            'deg' => Rational(10, 9),
+            'grad' => Rational(1),
+            'rad' => Rational(200, Math::PI),
+            'turn' => Rational(400)
+          },
+          'rad' => {
+            'deg' => Rational(Math::PI, 180),
+            'grad' => Rational(Math::PI, 200),
+            'rad' => Rational(1),
+            'turn' => Rational(2 * Math::PI)
+          },
+          'turn' => {
+            'deg' => Rational(1, 360),
+            'grad' => Rational(1, 400),
+            'rad' => Rational(1, 2 * Math::PI),
+            'turn' => Rational(1)
+          },
+
+          # Time
+          's' => {
+            's' => Rational(1),
+            'ms' => Rational(1, 1000)
+          },
+          'ms' => {
+            's' => Rational(1000),
+            'ms' => Rational(1)
+          },
+
+          # Frequency
+          'Hz' => {
+            'Hz' => Rational(1),
+            'kHz' => Rational(1000)
+          },
+          'kHz' => {
+            'Hz' => Rational(1, 1000),
+            'kHz' => Rational(1)
+          },
+
+          # Pixel density
+          'dpi' => {
+            'dpi' => Rational(1),
+            'dpcm' => Rational(2.54),
+            'dppx' => Rational(96)
+          },
+          'dpcm' => {
+            'dpi' => Rational(1, 2.54),
+            'dpcm' => Rational(1),
+            'dppx' => Rational(96, 2.54)
+          },
+          'dppx' => {
+            'dpi' => Rational(1, 96),
+            'dpcm' => Rational(2.54, 96),
+            'dppx' => Rational(1)
+          }
+        }.freeze
+
+        UNITS_BY_TYPE = {
+          time: %w[s ms],
+          frequency: %w[Hz kHz],
+          'pixel density': %w[dpi dpcm dppx]
+        }.freeze
+
+        TYPES_BY_UNIT = UNITS_BY_TYPE.invert
+                                     .to_a
+                                     .flat_map { |pair| pair[0].map { |key| [key, pair[1]] } }
+                                     .to_h
+
+        module_function
+
+        def conversion_factor(unit1, unit2)
+          return 1 if unit1 == unit2
+
+          CONVERSIONS.dig(unit1, unit2)
+        end
+
+        def canonicalize_units(units)
+          return units if units.empty?
+
+          if units.length == 1
+            type = TYPES_BY_UNIT[units.first]
+            return type.nil? ? units : [UNITS_BY_TYPE[type].first]
+          end
+
+          units.map do |unit|
+            type = TYPES_BY_UNIT[unit]
+            type.nil? ? units : [UNITS_BY_TYPE[type].first]
+          end.sort
+        end
+
+        def canonical_multiplier(units)
+          units.reduce(1) do |multiplier, unit|
+            multiplier * canonical_multiplier_for_unit(unit)
+          end
+        end
+
+        def canonical_multiplier_for_unit(unit)
+          inner_map = CONVERSIONS[unit]
+          inner_map.nil? ? 1 : 1 / inner_map.values.first
+        end
+      end
+
+      private_constant :Unit
+    end
+  end
+end

data/lib/sass/value/number.rb

@@ -0,0 +1,272 @@
+# frozen_string_literal: true
+
+module Sass
+  class Value
+    # Sass's number type.
+    class Number < Sass::Value
+      def initialize(value, numerator_units = [], denominator_units = []) # rubocop:disable Lint/MissingSuper
+        numerator_units = [numerator_units] if numerator_units.is_a?(::String)
+        denominator_units = [denominator_units] if denominator_units.is_a?(::String)
+
+        unless denominator_units.empty? && numerator_units.empty?
+          value = value.dup
+          numerator_units = numerator_units.dup
+          new_denominator_units = []
+
+          denominator_units.each do |denominator_unit|
+            index = numerator_units.find_index do |numerator_unit|
+              factor = Unit.conversion_factor(denominator_unit, numerator_unit)
+              if factor.nil?
+                false
+              else
+                value *= factor
+                true
+              end
+            end
+            if index.nil?
+              new_denominator_units.push(denominator_unit)
+            else
+              numerator_units.delete_at(index)
+            end
+          end
+
+          denominator_units = new_denominator_units
+        end
+
+        @value = value.freeze
+        @numerator_units = numerator_units.freeze
+        @denominator_units = denominator_units.freeze
+      end
+
+      attr_reader :value, :numerator_units, :denominator_units
+
+      def unitless?
+        numerator_units.empty? && denominator_units.empty?
+      end
+
+      def assert_unitless(name = nil)
+        raise error "Expected #{self} to have no units", name unless unitless?
+      end
+
+      def units?
+        !unitless?
+      end
+
+      def unit?(unit)
+        single_unit? && numerator_units.first == unit
+      end
+
+      def assert_unit(unit, name = nil)
+        raise error "Expected #{self} to have no unit \"#{unit}\"", name unless unit?(unit)
+      end
+
+      def integer?
+        FuzzyMath.integer?(value)
+      end
+
+      def assert_integer(name = nil)
+        raise error "#{self} is not an integer", name unless integer?
+
+        to_i
+      end
+
+      def to_i
+        FuzzyMath.to_i(value)
+      end
+
+      def assert_between(min, max, name = nil)
+        FuzzyMath.assert_between(value, min, max, name)
+      end
+
+      def compatible_with_unit?(unit)
+        single_unit? && !Unit.conversion_factor(numerator_units.first, unit).nil?
+      end
+
+      def convert(new_numerator_units, new_denominator_units, name = nil)
+        Number.new(convert_value(new_numerator_units, new_denominator_units, name), new_numerator_units,
+                   new_denominator_units)
+      end
+
+      def convert_value(new_numerator_units, new_denominator_units, name = nil)
+        coerce_or_convert_value(new_numerator_units, new_denominator_units,
+                                coerce_unitless: false,
+                                name: name)
+      end
+
+      def convert_to_match(other, name = nil, other_name = nil)
+        Number.new(convert_value_to_match(other, name, other_name), other.numerator_units, other.denominator_units)
+      end
+
+      def convert_value_to_match(other, name = nil, other_name = nil)
+        coerce_or_convert_value(other.numerator_units, other.denominator_units,
+                                coerce_unitless: false,
+                                name: name,
+                                other: other,
+                                other_name: other_name)
+      end
+
+      def coerce(new_numerator_units, new_denominator_units, name = nil)
+        Number.new(coerce_value(new_numerator_units, new_denominator_units, name), new_numerator_units,
+                   new_denominator_units)
+      end
+
+      def coerce_value(new_numerator_units, new_denominator_units, name = nil)
+        coerce_or_convert_value(new_numerator_units, new_denominator_units,
+                                coerce_unitless: true,
+                                name: name)
+      end
+
+      def coerce_value_to_unit(unit, name = nil)
+        coerce_value([unit], [], name)
+      end
+
+      def coerce_to_match(other, name = nil, other_name = nil)
+        Number.new(coerce_value_to_match(other, name, other_name), other.numerator_units, other.denominator_units)
+      end
+
+      def coerce_value_to_match(other, name = nil, other_name = nil)
+        coerce_or_convert_value(other.numerator_units, other.denominator_units,
+                                coerce_unitless: true,
+                                name: name,
+                                other: other,
+                                other_name: other_name)
+      end
+
+      def assert_number(_name = nil)
+        self
+      end
+
+      def ==(other)
+        return false unless other.is_a? Sass::Value::Number
+
+        return false if numerator_units.length != other.numerator_units.length ||
+                        denominator_units.length != other.denominator_units.length
+
+        return FuzzyMath.equals(value, other.value) if unitless?
+
+        if Unit.canonicalize_units(numerator_units) != Unit.canonicalize_units(other.numerator_units) &&
+           Unit.canonicalize_units(denominator_units) != Unit.canonicalize_units(other.denominator_units)
+          return false
+        end
+
+        FuzzyMath.equals(
+          (value *
+          Unit.canonical_multiplier(numerator_units) /
+          Unit.canonical_multiplier(denominator_units)),
+          (other.value *
+          Unit.canonical_multiplier(other.numerator_units) /
+          Unit.canonical_multiplier(other.denominator_units))
+        )
+      end
+
+      def hash
+        @hash ||= if unitless?
+                    FuzzyMath.hash(value)
+                  elsif single_unit?
+                    FuzzyMath.hash(
+                      value * Unit.canonical_multiplier_for_unit(numerator_units.first)
+                    )
+                  else
+                    FuzzyMath.hash(
+                      value * Unit.canonical_multiplier(numerator_units) / Unit.canonical_multiplier(denominator_units)
+                    )
+                  end
+      end
+
+      protected
+
+      def single_unit?
+        numerator_units.length == 1 && denominator_units.empty?
+      end
+
+      def coerce_or_convert_value(new_numerator_units, new_denominator_units,
+                                  coerce_unitless:,
+                                  name: nil,
+                                  other: nil,
+                                  other_name: nil)
+        if other && (other.numerator_units != new_denominator_units && other.denominator_units != new_denominator_units)
+          raise error "Expect #{other} to have units #{unit_string(new_numerator_units, new_denominator_units)}"
+        end
+
+        return value if numerator_units == new_numerator_units && denominator_units == new_denominator_units
+
+        return value if numerator_units == new_numerator_units && denominator_units == new_denominator_units
+
+        other_unitless = new_numerator_units.empty? && new_denominator_units.empty?
+
+        return value if coerce_unitless && (unitless? || other_unitless)
+
+        compatibility_error = lambda {
+          unless other.nil?
+            message = +"#{self} and"
+            message << " $#{other_name}:" unless other_name.nil?
+            message << " #{other} have incompatible units"
+            message << " (one has units and the other doesn't)" if unitless? || other_unitless
+            return error message, name
+          end
+
+          return error "Expected #{self} to have no units", name unless other_unitless
+
+          if new_numerator_units.length == 1 && new_denominator_units.empty?
+            type = Unit::TYPES_BY_UNIT[new_numerator_units.first]
+            return error "Expected #{self} to have a #{type} unit (#{Unit::UNITS_BY_TYPE[type].join(', ')})", name
+          end
+
+          unit_length = new_numerator_units.length + new_denominator_units.length
+          units = unit_string(new_numerator_units, new_denominator_units)
+          error "Expected #{self} to have unit#{unit_length > 1 ? 's' : ''} #{units}", name
+        }
+
+        result = value
+
+        old_numerator_units = numerator_units.dup
+        new_numerator_units.each do |new_numerator_unit|
+          index = old_numerator_units.find_index do |old_numerator_unit|
+            factor = Unit.conversion_factor(new_numerator_unit, old_numerator_unit)
+            if factor.nil?
+              false
+            else
+              result *= factor
+              true
+            end
+          end
+          raise compatibility_error.call if index.nil?
+
+          old_numerator_units.delete_at(index)
+        end
+
+        old_denominator_units = denominator_units.dup
+        new_denominator_units.each do |new_denominator_unit|
+          index = old_denominator_units.find_index do |old_denominator_unit|
+            factor = Unit.conversion_factor(new_denominator_unit, old_denominator_unit)
+            if factor.nil?
+              false
+            else
+              result /= factor
+              true
+            end
+          end
+          raise compatibility_error.call if index.nil?
+
+          old_denominator_units.delete_at(index)
+        end
+
+        raise compatibility_error.call unless old_numerator_units.empty? && old_denominator_units.empty?
+
+        result
+      end
+
+      def unit_string(numerator_units, denominator_units)
+        if numerator_units.empty?
+          return 'no units' if denominator_units.empty?
+
+          return denominator_units.length == 1 ? "#{denominator_units.first}^-1" : "(#{denominator_units.join('*')})^-1"
+        end
+
+        return numerator_units.join('*') if denominator_units.empty?
+
+        "#{numerator_units.join('*')}/#{denominator_units.join('*')}"
+      end
+    end
+  end
+end

data/lib/sass/value/string.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Sass
+  class Value
+    # Sass's string type.
+    class String < Sass::Value
+      def initialize(text = '', quoted: true) # rubocop:disable Lint/MissingSuper
+        @text = text.freeze
+        @quoted = quoted
+      end
+
+      attr_reader :text
+
+      def quoted?
+        @quoted
+      end
+
+      def sass_index_to_string_index(sass_index, name = nil)
+        index = sass_index.assert_number(name).assert_integer(name)
+        raise error('String index may not be 0', name) if index.zero?
+
+        if index.abs > text.length
+          raise error("Invalid index #{sass_index} for a string with #{text.length} characters",
+                      name)
+        end
+
+        index.negative? ? text.length + index : index - 1
+      end
+
+      def ==(other)
+        other.is_a?(Sass::Value::String) && other.text == text
+      end
+
+      def hash
+        @hash ||= text.hash
+      end
+
+      def assert_string(_name = nil)
+        self
+      end
+    end
+  end
+end

data/lib/sass/value.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+module Sass
+  # The abstract base class of Sass's value types.
+  class Value
+    def to_a
+      [self]
+    end
+
+    def to_bool
+      true
+    end
+
+    def to_map
+      nil
+    end
+
+    def to_nil
+      self
+    end
+
+    def separator
+      nil
+    end
+
+    def bracketed?
+      false
+    end
+
+    def sass_index_to_array_index(sass_index, name = nil)
+      index = sass_index.assert_number(name).assert_integer(name)
+      raise error('List index may not be 0', name) if index.zero?
+
+      if index.abs > to_a_length
+        raise error("Invalid index #{sass_index} for a list with #{to_a_length} elements",
+                    name)
+      end
+
+      index.negative? ? to_a_length + index : index - 1
+    end
+
+    def at(index)
+      index < 1 && index >= -1 ? self : nil
+    end
+
+    def [](index)
+      at(index)
+    end
+
+    def assert_boolean(name = nil)
+      raise error("#{self} is not a boolean", name)
+    end
+
+    def assert_calculation(name = nil)
+      raise error("#{self} is not a calculation", name)
+    end
+
+    def assert_color(name = nil)
+      raise error("#{self} is not a color", name)
+    end
+
+    def assert_function(name = nil)
+      raise error("#{self} is not a function", name)
+    end
+
+    def assert_map(name = nil)
+      raise error("#{self} is not a map", name)
+    end
+
+    def assert_number(name = nil)
+      raise error("#{self} is not a number", name)
+    end
+
+    def assert_string(name = nil)
+      raise error("#{self} is not a string", name)
+    end
+
+    def eql?(other)
+      self == other
+    end
+
+    private
+
+    def to_a_length
+      1
+    end
+
+    def error(message, name = nil)
+      Sass::ScriptError.new name.nil? ? message : "$#{name}: #{message}"
+    end
+  end
+end