sass-embedded 1.69.7-x86_64-darwin → 1.71.0-x86_64-darwin

data/lib/sass/compiler/host/protofier.rb

@@ -3,83 +3,385 @@
 module Sass
   class Compiler
     class Host
-      # The {Protofier} module.
+      # The {Protofier} class.
       #
       # It converts Pure Ruby types and Protobuf Ruby types.
-      module Protofier
-        module_function
-
-        def from_proto_canonicalize_context(canonicalize_request)
-          CanonicalizeContext.new(
-            canonicalize_request.containing_url == '' ? nil : canonicalize_request.containing_url,
-            canonicalize_request.from_import
-          )
+      class Protofier
+        def initialize(function_registry)
+          @function_registry = function_registry
         end
 
-        def from_proto_compile_response(compile_response)
-          oneof = compile_response.result
-          result = compile_response.public_send(oneof)
+        def to_proto(obj)
+          case obj
+          when Sass::Value::String
+            EmbeddedProtocol::Value.new(
+              string: EmbeddedProtocol::Value::String.new(
+                text: obj.text.to_str,
+                quoted: obj.quoted?
+              )
+            )
+          when Sass::Value::Number
+            EmbeddedProtocol::Value.new(
+              number: Number.to_proto(obj)
+            )
+          when Sass::Value::Color
+            if obj.instance_eval { !defined?(@hue) }
+              EmbeddedProtocol::Value.new(
+                rgb_color: EmbeddedProtocol::Value::RgbColor.new(
+                  red: obj.red,
+                  green: obj.green,
+                  blue: obj.blue,
+                  alpha: obj.alpha.to_f
+                )
+              )
+            elsif obj.instance_eval { !defined?(@saturation) }
+              EmbeddedProtocol::Value.new(
+                hwb_color: EmbeddedProtocol::Value::HwbColor.new(
+                  hue: obj.hue.to_f,
+                  whiteness: obj.whiteness.to_f,
+                  blackness: obj.blackness.to_f,
+                  alpha: obj.alpha.to_f
+                )
+              )
+            else
+              EmbeddedProtocol::Value.new(
+                hsl_color: EmbeddedProtocol::Value::HslColor.new(
+                  hue: obj.hue.to_f,
+                  saturation: obj.saturation.to_f,
+                  lightness: obj.lightness.to_f,
+                  alpha: obj.alpha.to_f
+                )
+              )
+            end
+          when Sass::Value::ArgumentList
+            EmbeddedProtocol::Value.new(
+              argument_list: EmbeddedProtocol::Value::ArgumentList.new(
+                id: obj.instance_eval { @id },
+                contents: obj.to_a.map { |element| to_proto(element) },
+                keywords: obj.keywords.to_h { |key, value| [key.to_s, to_proto(value)] },
+                separator: ListSeparator.to_proto(obj.separator)
+              )
+            )
+          when Sass::Value::List
+            EmbeddedProtocol::Value.new(
+              list: EmbeddedProtocol::Value::List.new(
+                contents: obj.to_a.map { |element| to_proto(element) },
+                separator: ListSeparator.to_proto(obj.separator),
+                has_brackets: obj.bracketed?
+              )
+            )
+          when Sass::Value::Map
+            EmbeddedProtocol::Value.new(
+              map: EmbeddedProtocol::Value::Map.new(
+                entries: obj.contents.map do |key, value|
+                  EmbeddedProtocol::Value::Map::Entry.new(
+                    key: to_proto(key),
+                    value: to_proto(value)
+                  )
+                end
+              )
+            )
+          when Sass::Value::Function
+            if obj.instance_eval { @id }
+              EmbeddedProtocol::Value.new(
+                compiler_function: EmbeddedProtocol::Value::CompilerFunction.new(
+                  id: obj.instance_eval { @id }
+                )
+              )
+            else
+              EmbeddedProtocol::Value.new(
+                host_function: EmbeddedProtocol::Value::HostFunction.new(
+                  id: @function_registry.register(obj.callback),
+                  signature: obj.signature
+                )
+              )
+            end
+          when Sass::Value::Mixin
+            EmbeddedProtocol::Value.new(
+              compiler_mixin: EmbeddedProtocol::Value::CompilerMixin.new(
+                id: obj.instance_eval { @id }
+              )
+            )
+          when Sass::Value::Calculation
+            EmbeddedProtocol::Value.new(
+              calculation: Calculation.to_proto(obj)
+            )
+          when Sass::Value::Boolean
+            EmbeddedProtocol::Value.new(
+              singleton: obj.value ? :TRUE : :FALSE
+            )
+          when Sass::Value::Null
+            EmbeddedProtocol::Value.new(
+              singleton: :NULL
+            )
+          else
+            raise Sass::ScriptError, "Unknown Sass::Value #{obj}"
+          end
+        end
+
+        def from_proto(proto)
+          oneof = proto.value
+          obj = proto.public_send(oneof)
           case oneof
-          when :failure
-            raise CompileError.new(
-              result.message,
-              result.formatted == '' ? nil : result.formatted,
-              result.stack_trace == '' ? nil : result.stack_trace,
-              from_proto_source_span(result.span),
-              compile_response.loaded_urls
-            )
-          when :success
-            CompileResult.new(
-              result.css,
-              result.source_map == '' ? nil : result.source_map,
-              compile_response.loaded_urls
+          when :string
+            Sass::Value::String.new(
+              obj.text,
+              quoted: obj.quoted
+            )
+          when :number
+            Number.from_proto(obj)
+          when :rgb_color
+            Sass::Value::Color.new(
+              red: obj.red,
+              green: obj.green,
+              blue: obj.blue,
+              alpha: obj.alpha
+            )
+          when :hsl_color
+            Sass::Value::Color.new(
+              hue: obj.hue,
+              saturation: obj.saturation,
+              lightness: obj.lightness,
+              alpha: obj.alpha
+            )
+          when :hwb_color
+            Sass::Value::Color.new(
+              hue: obj.hue,
+              whiteness: obj.whiteness,
+              blackness: obj.blackness,
+              alpha: obj.alpha
+            )
+          when :argument_list
+            Sass::Value::ArgumentList.new(
+              obj.contents.map do |element|
+                from_proto(element)
+              end,
+              obj.keywords.entries.to_h do |key, value|
+                [key.to_sym, from_proto(value)]
+              end,
+              ListSeparator.from_proto(obj.separator)
+            ).instance_eval do
+              @id = obj.id
+              self
+            end
+          when :list
+            Sass::Value::List.new(
+              obj.contents.map do |element|
+                from_proto(element)
+              end,
+              separator: ListSeparator.from_proto(obj.separator),
+              bracketed: obj.has_brackets
+            )
+          when :map
+            Sass::Value::Map.new(
+              obj.entries.to_h do |entry|
+                [from_proto(entry.key), from_proto(entry.value)]
+              end
             )
+          when :compiler_function
+            Sass::Value::Function.new(nil).instance_eval do
+              @id = obj.id
+              self
+            end
+          when :host_function
+            raise Sass::ScriptError, 'The compiler may not send Value.host_function to host'
+          when :compiler_mixin
+            Sass::Value::Mixin.send(:new).instance_eval do
+              @id = obj.id
+              self
+            end
+          when :calculation
+            Calculation.from_proto(obj)
+          when :singleton
+            case obj
+            when :TRUE
+              Sass::Value::Boolean::TRUE
+            when :FALSE
+              Sass::Value::Boolean::FALSE
+            when :NULL
+              Sass::Value::Null::NULL
+            else
+              raise Sass::ScriptError, "Unknown Value.singleton #{obj}"
+            end
           else
-            raise ArgumentError, "Unknown CompileResponse.result #{result}"
+            raise Sass::ScriptError, "Unknown Value.value #{obj}"
           end
         end
 
-        def from_proto_source_span(source_span)
-          return if source_span.nil?
+        # The {Number} Protofier.
+        module Number
+          module_function
 
-          Logger::SourceSpan.new(from_proto_source_location(source_span.start),
-                                 from_proto_source_location(source_span.end),
-                                 source_span.text,
-                                 source_span.url == '' ? nil : source_span.url,
-                                 source_span.context == '' ? nil : source_span.context)
+          def to_proto(obj)
+            EmbeddedProtocol::Value::Number.new(
+              value: obj.value.to_f,
+              numerators: obj.numerator_units,
+              denominators: obj.denominator_units
+            )
+          end
+
+          def from_proto(obj)
+            Sass::Value::Number.new(
+              obj.value, {
+                numerator_units: obj.numerators.to_a,
+                denominator_units: obj.denominators.to_a
+              }
+            )
+          end
         end
 
-        def from_proto_source_location(source_location)
-          return if source_location.nil?
+        private_constant :Number
+
+        # The {Calculation} Protofier.
+        module Calculation
+          module_function
 
-          Logger::SourceLocation.new(source_location.offset,
-                                     source_location.line,
-                                     source_location.column)
+          def to_proto(obj)
+            EmbeddedProtocol::Value::Calculation.new(
+              name: obj.name,
+              arguments: obj.arguments.map { |argument| CalculationValue.to_proto(argument) }
+            )
+          end
+
+          def from_proto(obj)
+            Sass::Value::Calculation.send(
+              :new,
+              obj.name,
+              obj.arguments.map { |argument| CalculationValue.from_proto(argument) }
+            )
+          end
         end
 
-        def to_proto_syntax(syntax)
-          case syntax&.to_sym
-          when :scss
-            EmbeddedProtocol::Syntax::SCSS
-          when :indented
-            EmbeddedProtocol::Syntax::INDENTED
-          when :css
-            EmbeddedProtocol::Syntax::CSS
-          else
-            raise ArgumentError, 'syntax must be one of :scss, :indented, :css'
+        private_constant :Calculation
+
+        # The {CalculationValue} Protofier.
+        module CalculationValue
+          module_function
+
+          def to_proto(value)
+            case value
+            when Sass::Value::Number
+              EmbeddedProtocol::Value::Calculation::CalculationValue.new(
+                number: Number.to_proto(value)
+              )
+            when Sass::Value::Calculation
+              EmbeddedProtocol::Value::Calculation::CalculationValue.new(
+                calculation: Calculation.to_proto(value)
+              )
+            when Sass::Value::String
+              EmbeddedProtocol::Value::Calculation::CalculationValue.new(
+                string: value.text
+              )
+            when Sass::CalculationValue::CalculationOperation
+              EmbeddedProtocol::Value::Calculation::CalculationValue.new(
+                operation: EmbeddedProtocol::Value::Calculation::CalculationOperation.new(
+                  operator: CalculationOperator.to_proto(value.operator),
+                  left: to_proto(value.left),
+                  right: to_proto(value.right)
+                )
+              )
+            else
+              raise Sass::ScriptError, "Unknown CalculationValue #{value}"
+            end
+          end
+
+          def from_proto(value)
+            oneof = value.value
+            obj = value.public_send(oneof)
+            case oneof
+            when :number
+              Number.from_proto(obj)
+            when :calculation
+              Calculation.from_proto(obj)
+            when :string
+              Sass::Value::String.new(obj, quoted: false)
+            when :operation
+              Sass::CalculationValue::CalculationOperation.new(
+                CalculationOperator.from_proto(obj.operator),
+                from_proto(obj.left),
+                from_proto(obj.right)
+              )
+            else
+              raise Sass::ScriptError, "Unknown CalculationValue #{value}"
+            end
           end
         end
 
-        def to_proto_output_style(style)
-          case style&.to_sym
-          when :expanded
-            EmbeddedProtocol::OutputStyle::EXPANDED
-          when :compressed
-            EmbeddedProtocol::OutputStyle::COMPRESSED
-          else
-            raise ArgumentError, 'style must be one of :expanded, :compressed'
+        private_constant :CalculationValue
+
+        # The {CalculationOperator} Protofier.
+        module CalculationOperator
+          module_function
+
+          def to_proto(operator)
+            case operator
+            when '+'
+              :PLUS
+            when '-'
+              :MINUS
+            when '*'
+              :TIMES
+            when '/'
+              :DIVIDE
+            else
+              raise Sass::ScriptError, "Unknown CalculationOperator #{separator}"
+            end
+          end
+
+          def from_proto(operator)
+            case operator
+            when :PLUS
+              '+'
+            when :MINUS
+              '-'
+            when :TIMES
+              '*'
+            when :DIVIDE
+              '/'
+            else
+              raise Sass::ScriptError, "Unknown CalculationOperator #{separator}"
+            end
           end
         end
+
+        private_constant :CalculationOperator
+
+        # The {ListSeparator} Protofier.
+        module ListSeparator
+          module_function
+
+          def to_proto(separator)
+            case separator
+            when ','
+              :COMMA
+            when ' '
+              :SPACE
+            when '/'
+              :SLASH
+            when nil
+              :UNDECIDED
+            else
+              raise Sass::ScriptError, "Unknown ListSeparator #{separator}"
+            end
+          end
+
+          def from_proto(separator)
+            case separator
+            when :COMMA
+              ','
+            when :SPACE
+              ' '
+            when :SLASH
+              '/'
+            when :UNDECIDED
+              nil
+            else
+              raise Sass::ScriptError, "Unknown ListSeparator #{separator}"
+            end
+          end
+        end
+
+        private_constant :ListSeparator
       end
 
       private_constant :Protofier

data/lib/sass/compiler/host.rb

@@ -5,7 +5,6 @@ require_relative 'host/importer_registry'
 require_relative 'host/logger_registry'
 require_relative 'host/protofier'
 require_relative 'host/structifier'
-require_relative 'host/value_protofier'
 
 module Sass
   class Compiler
@@ -13,8 +12,8 @@ module Sass
     #
     # It communicates with {Dispatcher} and handles the host logic.
     class Host
-      def initialize(dispatcher)
-        @dispatcher = dispatcher
+      def initialize(channel)
+        @channel = channel
       end
 
       def compile_request(path:,
@@ -46,12 +45,19 @@ module Sass
                       EmbeddedProtocol::InboundMessage::CompileRequest::StringInput.new(
                         source: source.to_str,
                         url: url&.to_s,
-                        syntax: Protofier.to_proto_syntax(syntax),
+                        syntax: @importer_registry.syntax_to_proto(syntax),
                         importer: (@importer_registry.register(importer) unless importer.nil?)
                       )
                     end,
             path: (File.absolute_path(path) unless path.nil?),
-            style: Protofier.to_proto_output_style(style),
+            style: case style&.to_sym
+                   when :expanded
+                     EmbeddedProtocol::OutputStyle::EXPANDED
+                   when :compressed
+                     EmbeddedProtocol::OutputStyle::COMPRESSED
+                   else
+                     raise ArgumentError, 'style must be one of :expanded, :compressed'
+                   end,
             charset:,
             source_map:,
             source_map_include_sources:,
@@ -60,11 +66,31 @@ module Sass
             alert_ascii:,
             alert_color:,
             quiet_deps:,
+            silent: logger == Logger.silent,
             verbose:
           ))
         end
 
-        Protofier.from_proto_compile_response(compile_response)
+        oneof = compile_response.result
+        result = compile_response.public_send(oneof)
+        case oneof
+        when :failure
+          raise CompileError.new(
+            result.message,
+            result.formatted == '' ? nil : result.formatted,
+            result.stack_trace == '' ? nil : result.stack_trace,
+            result.span.nil? ? nil : Logger::SourceSpan.new(result.span),
+            compile_response.loaded_urls
+          )
+        when :success
+          CompileResult.new(
+            result.css,
+            result.source_map == '' ? nil : result.source_map,
+            compile_response.loaded_urls
+          )
+        else
+          raise ArgumentError, "Unknown CompileResponse.result #{result}"
+        end
       end
 
       def version_request
@@ -74,14 +100,18 @@ module Sass
           ))
         end
 
-        lang = case version_response.implementation_name
-               when /\bdart\b/i
-                 '[Dart]'
-               else
-                 '[?]'
-               end
+        info = [
+          version_response.implementation_name,
+          version_response.implementation_version,
+          '(Sass Compiler)'
+        ]
+
+        case version_response.implementation_name
+        when 'dart-sass'
+          info << '[Dart]'
+        end
 
-        "#{version_response.implementation_name}\t#{version_response.implementation_version}\t(Sass Compiler)\t#{lang}"
+        info
       end
 
       def compile_response(message)
@@ -98,7 +128,7 @@ module Sass
         case message
         when EmbeddedProtocol::ProtocolError
           @error = Errno::EPROTO.new(message.message)
-          @channel.error(@error)
+          @stream.error(@error)
         else
           @error ||= message
         end
@@ -108,7 +138,7 @@ module Sass
       def log_event(message)
         @logger_registry.log(message)
       rescue StandardError => e
-        @channel.error(e)
+        @stream.error(e)
       end
 
       def canonicalize_request(message)
@@ -156,7 +186,7 @@ module Sass
 
       def listen
         @queue = Queue.new
-        @channel = @dispatcher.connect(self)
+        @stream = @channel.stream(self)
 
         yield
 
@@ -164,22 +194,22 @@ module Sass
 
         @result
       ensure
-        @channel&.disconnect
+        @stream&.close
         @queue&.close
       end
 
       def id
-        @channel.id
+        @stream.id
       end
 
       def send_message0(...)
         inbound_message = EmbeddedProtocol::InboundMessage.new(...)
-        @channel.send_proto(0, inbound_message.to_proto)
+        @stream.send_proto(0, inbound_message.to_proto)
       end
 
       def send_message(...)
         inbound_message = EmbeddedProtocol::InboundMessage.new(...)
-        @channel.send_proto(id, inbound_message.to_proto)
+        @stream.send_proto(id, inbound_message.to_proto)
       end
     end
 

data/lib/sass/compiler.rb

@@ -2,32 +2,35 @@
 
 require_relative 'canonicalize_context'
 require_relative 'compile_result'
+require_relative 'compiler/channel'
 require_relative 'compiler/connection'
 require_relative 'compiler/dispatcher'
-require_relative 'compiler/dispatcher_manager'
 require_relative 'compiler/host'
 require_relative 'compiler/varint'
+require_relative 'embedded/version'
 require_relative 'embedded_protocol'
 require_relative 'exception'
 require_relative 'fork_tracker'
 require_relative 'logger/silent'
 require_relative 'logger/source_location'
 require_relative 'logger/source_span'
+require_relative 'node_package_importer'
 require_relative 'serializer'
 require_relative 'value'
 
 module Sass
-  # The {Compiler} for using dart-sass. Each instance creates its own
-  # communication {Dispatcher} with a dedicated compiler process.
+  # A synchronous {Compiler}.
+  # Each compiler instance exposes the {#compile} and {#compile_string} methods within the lifespan of the compiler.
   #
   # @example
   #   sass = Sass::Compiler.new
   #   result = sass.compile_string('h1 { font-size: 40px; }')
   #   result = sass.compile('style.scss')
   #   sass.close
+  # @see https://sass-lang.com/documentation/js-api/classes/compiler/
   class Compiler
     def initialize
-      @dispatcher = DispatcherManager.new(Dispatcher)
+      @channel = Channel.new(Dispatcher)
     end
 
     # Compiles the Sass file at +path+ to CSS.
@@ -76,7 +79,7 @@ module Sass
                 verbose: false)
       raise ArgumentError, 'path must be set' if path.nil?
 
-      Host.new(@dispatcher).compile_request(
+      Host.new(@channel).compile_request(
         path:,
         source: nil,
         importer: nil,
@@ -150,7 +153,7 @@ module Sass
                        verbose: false)
       raise ArgumentError, 'source must be set' if source.nil?
 
-      Host.new(@dispatcher).compile_request(
+      Host.new(@channel).compile_request(
         path: nil,
         source:,
         importer:,
@@ -174,18 +177,18 @@ module Sass
     # @return [String] Information about the Sass implementation.
     # @see https://sass-lang.com/documentation/js-api/variables/info/
     def info
-      @info ||= <<~INFO.freeze
-        sass-embedded\t#{Embedded::VERSION}\t(Embedded Host)\t[Ruby]
-        #{Host.new(@dispatcher).version_request}
-      INFO
+      @info ||= [
+        ['sass-embedded', Embedded::VERSION, '(Embedded Host)', '[Ruby]'].join("\t"),
+        Host.new(@channel).version_request.join("\t")
+      ].join("\n").freeze
     end
 
     def close
-      @dispatcher.close
+      @channel.close
     end
 
     def closed?
-      @dispatcher.closed?
+      @channel.closed?
     end
   end
 end

data/lib/sass/embedded/version.rb

@@ -2,6 +2,6 @@
 
 module Sass
   module Embedded
-    VERSION = '1.69.7'
+    VERSION = '1.71.0'
   end
 end