sass-embedded 0.14.0 → 0.16.2

data/lib/sass/embedded/version.rb

@@ -2,6 +2,6 @@
 
 module Sass
   class Embedded
-    VERSION = '0.14.0'
+    VERSION = '0.16.2'
   end
 end

data/lib/sass/embedded/version_context.rb

@@ -1,8 +1,5 @@
 # frozen_string_literal: true
 
-require_relative '../embedded_protocol'
-require_relative 'observer'
-
 module Sass
   class Embedded
     # The {Observer} for {Embedded#info}.
@@ -32,5 +29,7 @@ module Sass
         end
       end
     end
+
+    private_constant :VersionContext
   end
 end

data/lib/sass/embedded.rb

@@ -1,19 +1,8 @@
 # frozen_string_literal: true
 
-require_relative 'compile_error'
-require_relative 'compile_result'
-require_relative 'embedded/channel'
-require_relative 'embedded/compile_context'
-require_relative 'embedded/render'
-require_relative 'embedded/url'
-require_relative 'embedded/version'
-require_relative 'embedded/version_context'
-require_relative 'importer_result'
-require_relative 'logger'
-
 module Sass
   # The {Embedded} host for using dart-sass-embedded. Each instance creates
-  # its own {Channel}.
+  # its own communication {Channel} with a dedicated compiler process.
   #
   # @example
   #   embedded = Sass::Embedded.new
@@ -48,27 +37,25 @@ module Sass
 
       raise ArgumentError, 'path must be set' if path.nil?
 
-      message = CompileContext.new(@channel,
-                                   path: path,
-                                   source: nil,
-                                   importer: nil,
-                                   load_paths: load_paths,
-                                   syntax: nil,
-                                   url: nil,
-                                   source_map: source_map,
-                                   source_map_include_sources: source_map_include_sources,
-                                   style: style,
-                                   functions: functions,
-                                   importers: importers,
-                                   alert_color: alert_color,
-                                   alert_ascii: alert_ascii,
-                                   logger: logger,
-                                   quiet_deps: quiet_deps,
-                                   verbose: verbose).receive_message
-
-      raise CompileError.from_proto(message.failure) if message.failure
-
-      CompileResult.from_proto(message.success)
+      Protofier.from_proto_compile_response(
+        CompileContext.new(@channel,
+                           path: path,
+                           source: nil,
+                           importer: nil,
+                           load_paths: load_paths,
+                           syntax: nil,
+                           url: nil,
+                           source_map: source_map,
+                           source_map_include_sources: source_map_include_sources,
+                           style: style,
+                           functions: functions,
+                           importers: importers,
+                           alert_color: alert_color,
+                           alert_ascii: alert_ascii,
+                           logger: logger,
+                           quiet_deps: quiet_deps,
+                           verbose: verbose).receive_message
+      )
     end
 
     # The {Embedded#compile_string} method.
@@ -96,27 +83,25 @@ module Sass
                        verbose: false)
       raise ArgumentError, 'source must be set' if source.nil?
 
-      message = CompileContext.new(@channel,
-                                   path: nil,
-                                   source: source,
-                                   importer: importer,
-                                   load_paths: load_paths,
-                                   syntax: syntax,
-                                   url: url,
-                                   source_map: source_map,
-                                   source_map_include_sources: source_map_include_sources,
-                                   style: style,
-                                   functions: functions,
-                                   importers: importers,
-                                   alert_color: alert_color,
-                                   alert_ascii: alert_ascii,
-                                   logger: logger,
-                                   quiet_deps: quiet_deps,
-                                   verbose: verbose).receive_message
-
-      raise CompileError.from_proto(message.failure) if message.failure
-
-      CompileResult.from_proto(message.success)
+      Protofier.from_proto_compile_response(
+        CompileContext.new(@channel,
+                           path: nil,
+                           source: source,
+                           importer: importer,
+                           load_paths: load_paths,
+                           syntax: syntax,
+                           url: url,
+                           source_map: source_map,
+                           source_map_include_sources: source_map_include_sources,
+                           style: style,
+                           functions: functions,
+                           importers: importers,
+                           alert_color: alert_color,
+                           alert_ascii: alert_ascii,
+                           logger: logger,
+                           quiet_deps: quiet_deps,
+                           verbose: verbose).receive_message
+      )
     end
 
     # The {Embedded#info} method.

data/lib/sass/embedded_protocol.rb

@@ -1,9 +1,3 @@
 # frozen_string_literal: true
 
 require_relative '../../ext/sass/embedded_sass_pb'
-
-module Sass
-  module EmbeddedProtocol
-    PROTOCOL_ERROR_ID = 4_294_967_295
-  end
-end

data/lib/sass/logger/source_location.rb

@@ -2,7 +2,9 @@
 
 module Sass
   module Logger
-    # The {SourceLocation} in {SourceSpan}.
+    # A specific location within a source file.
+    #
+    # This is always associated with a {SourceSpan} which indicates which file it refers to.
     class SourceLocation
       attr_reader :offset, :line, :column
 
@@ -11,14 +13,6 @@ module Sass
         @line = line
         @column = column
       end
-
-      def self.from_proto(source_location)
-        return nil if source_location.nil?
-
-        SourceLocation.new(source_location.offset,
-                           source_location.line,
-                           source_location.column)
-      end
     end
   end
 end

data/lib/sass/logger/source_span.rb

@@ -1,10 +1,8 @@
 # frozen_string_literal: true
 
-require_relative 'source_location'
-
 module Sass
   module Logger
-    # The {SourceSpan} in {CompileError}.
+    # A span of text within a source file.
     class SourceSpan
       attr_reader :start, :end, :text, :url, :context
 
@@ -15,16 +13,6 @@ module Sass
         @url = url == '' ? nil : url
         @context = context == '' ? nil : context
       end
-
-      def self.from_proto(source_span)
-        return nil if source_span.nil?
-
-        SourceSpan.new(SourceLocation.from_proto(source_span.start),
-                       SourceLocation.from_proto(source_span.end),
-                       source_span.text,
-                       source_span.url,
-                       source_span.context)
-      end
     end
   end
 end

data/lib/sass/logger.rb

@@ -1,16 +1,16 @@
 # frozen_string_literal: true
 
 module Sass
-  # The {Logger} module.
+  # A namespace for built-in Loggers.
   module Logger
     module_function
 
-    # The instance of a silent {Logger}.
+    # A Logger that silently ignores all warnings and debug messages.
     def silent
       Silent
     end
 
-    # The silent {Logger}.
+    # A Logger that silently ignores all warnings and debug messages.
     module Silent
       module_function
 

data/lib/sass/script_error.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Sass
+  class ScriptError < StandardError; end
+end

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