sass-embedded 1.69.7-arm-linux-gnueabihf → 1.70.0-arm-linux-gnueabihf

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

data/lib/sass/compiler.rb

@@ -7,6 +7,7 @@ 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'
@@ -174,10 +175,10 @@ 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(@dispatcher).version_request.join("\t")
+      ].join("\n").freeze
     end
 
     def close

data/lib/sass/embedded/version.rb

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

data/lib/sass/embedded.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 require_relative 'compiler'
-require_relative 'embedded/version'
 
 # The Sass module.
 #

data/lib/sass/exception.rb

@@ -28,7 +28,7 @@ module Sass
 
       highlight = Exception.respond_to?(:to_tty?) && Exception.to_tty? if highlight.nil?
       if highlight
-        +@full_message
+        @full_message.dup
       else
         @full_message.gsub(/\e\[[0-9;]*m/, '')
       end
@@ -38,7 +38,7 @@ module Sass
     def to_css
       content = full_message(highlight: false, order: :top)
 
-      <<~CSS
+      <<~CSS.freeze
         /* #{content.gsub('*/', "*\u2060/").gsub("\r\n", "\n").split("\n").join("\n * ")} */
 
         body::before {
@@ -50,7 +50,11 @@ module Sass
           border-bottom-style: solid;
           font-family: monospace, monospace;
           white-space: pre;
-          content: #{Serializer.serialize_quoted_string(content, ascii_only: true)};
+          content: #{Serializer.serialize_quoted_string(content).gsub(/[^[:ascii:]][\h\t ]?/) do |match|
+            replacement = "\\#{match.ord.to_s(16)}"
+            replacement << " #{match[1]}" if match.length > 1
+            replacement
+          end};
         }
       CSS
     end

data/lib/sass/logger/source_location.rb

@@ -12,10 +12,10 @@ module Sass
       attr_reader :offset, :line, :column
 
       # @!visibility private
-      def initialize(offset, line, column)
-        @offset = offset
-        @line = line
-        @column = column
+      def initialize(source_location)
+        @offset = source_location.offset
+        @line = source_location.line
+        @column = source_location.column
       end
     end
   end

data/lib/sass/logger/source_span.rb

@@ -16,12 +16,12 @@ module Sass
       attr_reader :url, :context
 
       # @!visibility private
-      def initialize(start, end_, text, url, context)
-        @start = start
-        @end = end_
-        @text = text
-        @url = url
-        @context = context
+      def initialize(source_span)
+        @start = source_span.start.nil? ? nil : Logger::SourceLocation.new(source_span.start)
+        @end = source_span.end.nil? ? nil : Logger::SourceLocation.new(source_span.end)
+        @text = source_span.text
+        @url = source_span.url == '' ? nil : source_span.url
+        @context = source_span.context == '' ? nil : source_span.context
       end
     end
   end