sass-embedded 1.69.1 → 1.69.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ae83f7f88503d1c7001b81342c7e101361ea96ce9cfa73b73269e9bfa37a6fd3
-  data.tar.gz: 9c9b5115d21cc5a502da73d47f95d6d5bd9350fa0d4c70fabb1658beb3acec39
+  metadata.gz: 5ddf58c29aaacc85fb79d2f70cccf60ef11566a7dd961ce4d1b6753580e63be7
+  data.tar.gz: 3f94c4fc1435af31542aba4af84997a0e3628372ead2fe0e61a5eafd35270d76
 SHA512:
-  metadata.gz: cfeb10f453f62ecf33d398659fd47e951fa3565803f2891ebc3c7beec65130c8caf8046a85c2b466c026ee442eeac2a2ff1ad534742b6f47b6756471f8f245c9
-  data.tar.gz: 6249ad82375ba882dc5652a9db29d9a0c00f8edc57da07d9b3fec3f32cea715bdcc6a2e85baeeb4e08e16c83cea57cff3fef7c355e1532d072443379588e5d5f
+  metadata.gz: 91a8794f30f711b9e5f3c23e93aeff8e2849c194f1774a3125c69d06f71b5e0a195a8b8114701ee27089b7bd5b6ecd922aaaabcc3886577aab0e0c2668c2ddac
+  data.tar.gz: b51d8a8acd12db57a88293a9f8a4b6c0efebc8591e167ae7e3ce56dbf776d1cc0d2e64c980ceb78802356659afc142a9f6128e11e1e3264340074d0aef664acc

data/README.md

@@ -1,6 +1,6 @@
 # Embedded Sass Host for Ruby
 
-[![build](https://github.com/ntkme/sass-embedded-host-ruby/actions/workflows/build.yml/badge.svg)](https://github.com/ntkme/sass-embedded-host-ruby/actions/workflows/build.yml)
+[![build](https://github.com/sass-contrib/sass-embedded-host-ruby/actions/workflows/build.yml/badge.svg)](https://github.com/sass-contrib/sass-embedded-host-ruby/actions/workflows/build.yml)
 [![gem](https://badge.fury.io/rb/sass-embedded.svg)](https://rubygems.org/gems/sass-embedded)
 
 This is a Ruby library that implements the host side of the [Embedded Sass protocol](https://github.com/sass/sass/blob/HEAD/spec/embedded-protocol.md).

data/exe/sass

@@ -7,13 +7,13 @@ module Sass
   # The `sass` command line interface
   class CLI
     begin
-      exec(*COMMAND, *ARGV)
+      Kernel.exec(*COMMAND, *ARGV)
     rescue Errno::ENOENT
       require_relative '../lib/sass/elf'
 
       raise if ELF::INTERPRETER.nil?
 
-      exec(ELF::INTERPRETER, *COMMAND, *ARGV)
+      Kernel.exec(ELF::INTERPRETER, *COMMAND, *ARGV)
     end
   end
 

data/ext/sass/Rakefile

@@ -41,12 +41,12 @@ file 'cli.rb' => %w[dart-sass] do |t|
 
   command = if File.exist?(runtime) && File.exist?(snapshot)
               "
-      File.absolute_path('#{runtime}', __dir__),
-      File.absolute_path('#{snapshot}', __dir__)
+      File.absolute_path('#{runtime}', __dir__).freeze,
+      File.absolute_path('#{snapshot}', __dir__).freeze
     "
             else
               "
-      File.absolute_path('#{exe}', __dir__)
+      File.absolute_path('#{exe}', __dir__).freeze
     "
             end
 
@@ -164,7 +164,7 @@ module FileUtils
       cp source_path, dest_path
     else
       fetcher = Gem::RemoteFetcher.fetcher
-      symbol = "fetch_#{scheme}".to_sym
+      symbol = :"fetch_#{scheme}"
       raise ArgumentError, "Unsupported URI scheme #{scheme}" unless fetcher.respond_to?(symbol)
 
       if Rake::FileUtilsExt.verbose_flag
@@ -207,10 +207,10 @@ module FileUtils
     raise if spec.nil? || source.nil?
 
     if Rake::FileUtilsExt.nowrite_flag
-      installer = Gem::Installer.for_spec(spec, { force: true, install_dir: install_dir })
+      installer = Gem::Installer.for_spec(spec, { force: true, install_dir: })
     else
       path = source.download(spec, install_dir)
-      installer = Gem::Installer.at(path, { force: true, install_dir: install_dir })
+      installer = Gem::Installer.at(path, { force: true, install_dir: })
       installer.install
     end
 
@@ -251,27 +251,13 @@ module SassConfig
             'arm'
           when /ppc64le|powerpc64le/
             'powerpc64le'
-          when /s390x/
-            's390x'
           else
             RbConfig::CONFIG['host_cpu']
           end
 
     ARCH = "#{CPU}-#{OS}".freeze
 
-    EMULATION = if ARCH == 'aarch64-windows'
-                  begin
-                    require_relative 'win32_api'
-
-                    if Win32API.x64?
-                      'x86_64'
-                    elsif Win32API.x86?
-                      'i386'
-                    end
-                  rescue LoadError
-                    'i386'
-                  end
-                end
+    EMULATION = ('x86_64' if ARCH == 'aarch64-windows')
   end
 
   private_constant :Platform
@@ -299,11 +285,9 @@ module SassConfig
          when 'linux'
            'linux'
          when 'linux-android'
-           repo = 'https://github.com/dart-android/dart-sass'
            'android'
          when 'linux-musl'
-           repo = 'https://github.com/dart-musl/dart-sass'
-           'linux'
+           'linux-musl'
          when 'windows'
            'windows'
          else

data/ext/sass/embedded_sass_pb.rb

@@ -11,7 +11,7 @@ pool = Google::Protobuf::DescriptorPool.generated_pool
 
 begin
   pool.add_serialized_file(descriptor_data)
-rescue TypeError => e
+rescue TypeError
   # Compatibility code: will be removed in the next major version.
   require 'google/protobuf/descriptor_pb'
   parsed = Google::Protobuf::FileDescriptorProto.decode(descriptor_data)

data/ext/sass/package.json

@@ -1,5 +1,5 @@
 {
   "dependencies": {
-    "sass": "1.69.1"
+    "sass": "1.69.7"
   }
 }

data/lib/sass/calculation_value/calculation_operation.rb

@@ -18,12 +18,9 @@ module Sass
       def initialize(operator, left, right)
         raise Sass::ScriptError, "Invalid operator: #{operator}" unless OPERATORS.include?(operator)
 
-        left.assert_calculation_value
-        right.assert_calculation_value
-
         @operator = operator.freeze
-        @left = left.freeze
-        @right = right.freeze
+        @left = assert_calculation_value(left, 'left')
+        @right = assert_calculation_value(right, 'right')
       end
 
       # @return [::String]

data/lib/sass/calculation_value.rb

@@ -5,10 +5,16 @@ module Sass
   #
   # @see https://sass-lang.com/documentation/js-api/types/calculationvalue/
   module CalculationValue
-    # @return [CalculationValue]
-    # @raise [ScriptError]
-    def assert_calculation_value(_name = nil)
-      self
+    private
+
+    def assert_calculation_value(value, name = nil)
+      if !value.is_a?(Sass::CalculationValue) || (value.is_a?(Sass::Value::String) && value.quoted?)
+        raise Sass::ScriptError.new(
+          "#{value} must be one of SassNumber, unquoted SassString, SassCalculation, CalculationOperation", name
+        )
+      end
+
+      value
     end
   end
 end

data/lib/sass/compiler/connection.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+require 'open3'
+
+require_relative '../../../ext/sass/cli'
+
+module Sass
+  class Compiler
+    # The stdio based {Connection} between the {Dispatcher} and the compiler.
+    #
+    # It runs the `sass --embedded` command.
+    class Connection
+      def initialize(dispatcher)
+        @mutex = Mutex.new
+        @stdin, @stdout, @stderr, @wait_thread = begin
+          Open3.popen3(*CLI::COMMAND, '--embedded', chdir: __dir__)
+        rescue Errno::ENOENT
+          require_relative '../elf'
+
+          raise if ELF::INTERPRETER.nil?
+
+          Open3.popen3(ELF::INTERPRETER, *CLI::COMMAND, '--embedded', chdir: __dir__)
+        end
+
+        @stdin.binmode
+
+        Thread.new do
+          Thread.current.name = "sass-embedded-process-stdout-poller-#{@wait_thread.pid}"
+
+          # # https://dart.dev/tools/dart-devtools
+          # if 'dart' == File.basename(CLI::COMMAND.first, '.exe') && CLI::COMMAND.include?('--observe')
+          #   Kernel.warn(@stdout.readline, uplevel: 0)
+          #   Kernel.warn(@stdout.readline, uplevel: 0)
+          # end
+
+          @stdout.binmode
+
+          loop do
+            length = Varint.read(@stdout)
+            id = Varint.read(@stdout)
+            proto = @stdout.read(length - Varint.length(id))
+            dispatcher.receive_proto(id, proto)
+          end
+        rescue IOError, Errno::EBADF, Errno::EPROTO => e
+          dispatcher.error(e)
+          @mutex.synchronize do
+            @stdout.close
+          end
+        end
+
+        Thread.new do
+          Thread.current.name = "sass-embedded-process-stderr-poller-#{@wait_thread.pid}"
+          loop do
+            Kernel.warn(@stderr.readline, uplevel: 0)
+          end
+        rescue IOError, Errno::EBADF
+          @mutex.synchronize do
+            @stderr.close
+          end
+        end
+
+        @wait_thread.name = "sass-embedded-process-waiter-#{@wait_thread.pid}"
+      end
+
+      def close
+        @mutex.synchronize do
+          @stdin.close
+          @wait_thread.join
+          @stdout.close
+          @stderr.close
+        end
+      end
+
+      def closed?
+        @mutex.synchronize do
+          @stdin.closed? && !@wait_thread.alive?
+        end
+      end
+
+      def write(id, proto)
+        buffer = []
+        Varint.write(buffer, Varint.length(id) + proto.length)
+        Varint.write(buffer, id)
+        @mutex.synchronize do
+          @stdin.write(buffer.pack('C*'), proto)
+        end
+      end
+    end
+
+    private_constant :Connection
+  end
+end

data/lib/sass/{embedded → compiler}/dispatcher.rb

@@ -1,38 +1,22 @@
 # frozen_string_literal: true
 
 module Sass
-  class Embedded
+  class Compiler
     # The {Dispatcher} class.
     #
     # It dispatches messages between mutliple instances of {Host} and a single {Connection} to the compiler.
     class Dispatcher
-      UINT_MAX = 0xffffffff
-
       def initialize
-        @connection = Connection.new
-        @observers = {}
         @id = 1
+        @observers = {}
         @mutex = Mutex.new
-
-        Thread.new do
-          loop do
-            receive_proto
-          rescue IOError, Errno::EBADF, Errno::EPROTO => e
-            values = @mutex.synchronize do
-              @id = UINT_MAX
-              @observers.values
-            end
-            values.each do |observer|
-              observer.error(e)
-            end
-            break
-          end
-        end
+        @connection = Connection.new(self)
+        ForkTracker.add(self)
       end
 
       def subscribe(observer)
         @mutex.synchronize do
-          raise Errno::EBUSY if @id == UINT_MAX
+          raise Errno::EBUSY if _closed?
 
           id = @id
           @id = id.next
@@ -47,12 +31,12 @@ module Sass
 
           return unless @observers.empty?
 
-          if @id == UINT_MAX
+          if _closed?
             Thread.new do
               close
             end
           else
-            @id = 1
+            _idle
           end
         end
       end
@@ -62,36 +46,42 @@ module Sass
       end
 
       def close
+        @mutex.synchronize do
+          _close
+        end
         @connection.close
+        ForkTracker.delete(self)
       end
 
       def closed?
         @connection.closed?
       end
 
-      def error
-        @mutex.synchronize do
-          @id = UINT_MAX
+      def error(error)
+        observers = @mutex.synchronize do
+          _close
+          @observers.values
         end
-      end
 
-      def send_proto(...)
-        @connection.write(...)
+        if observers.empty?
+          close
+        else
+          observers.each do |observer|
+            observer.error(error)
+          end
+        end
       end
 
-      private
-
-      def receive_proto
-        id, proto = @connection.read
+      def receive_proto(id, proto)
         case id
-        when 1...UINT_MAX
-          @mutex.synchronize { @observers[id] }.receive_proto(proto)
+        when 1...0xffffffff
+          @mutex.synchronize { @observers[id] }&.receive_proto(proto)
         when 0
           outbound_message = EmbeddedProtocol::OutboundMessage.decode(proto)
           oneof = outbound_message.message
           message = outbound_message.public_send(oneof)
-          @mutex.synchronize { @observers[message.id] }.public_send(oneof, message)
-        when UINT_MAX
+          @mutex.synchronize { @observers[message.id] }&.public_send(oneof, message)
+        when 0xffffffff
           outbound_message = EmbeddedProtocol::OutboundMessage.decode(proto)
           oneof = outbound_message.message
           message = outbound_message.public_send(oneof)
@@ -101,6 +91,28 @@ module Sass
         end
       end
 
+      def send_proto(...)
+        @connection.write(...)
+      end
+
+      private
+
+      def _close
+        @id = 0xffffffff
+      end
+
+      def _closed?
+        @id == 0xffffffff
+      end
+
+      def _idle
+        @id = 1
+      end
+
+      def _idle?
+        @id == 1
+      end
+
       # The {Channel} between {Dispatcher} and {Host}.
       class Channel
         attr_reader :id
@@ -111,7 +123,11 @@ module Sass
         end
 
         def disconnect
-          @dispatcher.unsubscribe(id)
+          @dispatcher.unsubscribe(@id)
+        end
+
+        def error(...)
+          @dispatcher.error(...)
         end
 
         def send_proto(...)

data/lib/sass/compiler/dispatcher_manager.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Sass
+  class Compiler
+    # The {DispatcherManager} class.
+    #
+    # It manages the lifecycle of {Dispatcher}.
+    class DispatcherManager
+      def initialize(dispatcher_class)
+        @dispatcher_class = dispatcher_class
+        @dispatcher = @dispatcher_class.new
+        @mutex = Mutex.new
+      end
+
+      def close
+        @mutex.synchronize do
+          unless @dispatcher.nil?
+            @dispatcher.close
+            @dispatcher = nil
+          end
+        end
+      end
+
+      def closed?
+        @mutex.synchronize do
+          @dispatcher.nil?
+        end
+      end
+
+      def connect(...)
+        @mutex.synchronize do
+          raise IOError, 'closed compiler' if @dispatcher.nil?
+
+          @dispatcher.connect(...)
+        rescue Errno::EBUSY
+          @dispatcher = @dispatcher_class.new
+          @dispatcher.connect(...)
+        end
+      end
+    end
+
+    private_constant :DispatcherManager
+  end
+end

data/lib/sass/{embedded → compiler}/host/function_registry.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module Sass
-  class Embedded
+  class Compiler
     class Host
       # The {FunctionRegistry} class.
       #
@@ -55,8 +55,8 @@ module Sass
 
           EmbeddedProtocol::InboundMessage::FunctionCallResponse.new(
             id: function_call_request.id,
-            success: success,
-            accessed_argument_lists: accessed_argument_lists
+            success:,
+            accessed_argument_lists:
           )
         rescue StandardError => e
           EmbeddedProtocol::InboundMessage::FunctionCallResponse.new(

data/lib/sass/{embedded → compiler}/host/importer_registry.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module Sass
-  class Embedded
+  class Compiler
     class Host
       # The {ImporterRegistry} class.
       #
@@ -65,7 +65,7 @@ module Sass
 
           EmbeddedProtocol::InboundMessage::CanonicalizeResponse.new(
             id: canonicalize_request.id,
-            url: url
+            url:
           )
         rescue StandardError => e
           EmbeddedProtocol::InboundMessage::CanonicalizeResponse.new(
@@ -81,7 +81,7 @@ module Sass
           EmbeddedProtocol::InboundMessage::ImportResponse.new(
             id: import_request.id,
             success: EmbeddedProtocol::InboundMessage::ImportResponse::ImportSuccess.new(
-              contents: importer_result.contents,
+              contents: importer_result.contents.to_str,
               syntax: Protofier.to_proto_syntax(importer_result.syntax),
               source_map_url: (importer_result.source_map_url&.to_s if importer_result.respond_to?(:source_map_url))
             )
@@ -100,7 +100,7 @@ module Sass
 
           EmbeddedProtocol::InboundMessage::FileImportResponse.new(
             id: file_import_request.id,
-            file_url: file_url
+            file_url:
           )
         rescue StandardError => e
           EmbeddedProtocol::InboundMessage::FileImportResponse.new(

data/lib/sass/{embedded → compiler}/host/logger_registry.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module Sass
-  class Embedded
+  class Compiler
     class Host
       # The {LoggerRegistry} class.
       #

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

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+module Sass
+  class Compiler
+    class Host
+      # The {Protofier} module.
+      #
+      # 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
+          )
+        end
+
+        def 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,
+              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
+            )
+          else
+            raise ArgumentError, "Unknown CompileResponse.result #{result}"
+          end
+        end
+
+        def from_proto_source_span(source_span)
+          return if source_span.nil?
+
+          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)
+        end
+
+        def from_proto_source_location(source_location)
+          return if source_location.nil?
+
+          Logger::SourceLocation.new(source_location.offset,
+                                     source_location.line,
+                                     source_location.column)
+        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'
+          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'
+          end
+        end
+      end
+
+      private_constant :Protofier
+    end
+  end
+end

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

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Sass
+  class Compiler
+    class Host
+      # The {Structifier} module.
+      #
+      # It converts {::Hash} to {Struct}-like objects.
+      module Structifier
+        module_function
+
+        def to_struct(obj, *symbols)
+          return obj unless obj.is_a?(Hash)
+
+          struct = Object.new
+          symbols.each do |key|
+            next unless obj.key?(key)
+
+            value = obj[key]
+            if value.respond_to?(:call)
+              struct.define_singleton_method key do |*args, **kwargs|
+                value.call(*args, **kwargs)
+              end
+            else
+              struct.define_singleton_method key do
+                value
+              end
+            end
+          end
+          struct
+        end
+      end
+
+      private_constant :Structifier
+    end
+  end
+end

data/lib/sass/{embedded → compiler}/host/value_protofier.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module Sass
-  class Embedded
+  class Compiler
     class Host
       # The {ValueProtofier} class.
       #
@@ -16,7 +16,7 @@ module Sass
           when Sass::Value::String
             EmbeddedProtocol::Value.new(
               string: EmbeddedProtocol::Value::String.new(
-                text: obj.text,
+                text: obj.text.to_str,
                 quoted: obj.quoted?
               )
             )
@@ -179,7 +179,7 @@ module Sass
               end
             )
           when :compiler_function
-            Sass::Value::Function.new(nil, nil).instance_eval do
+            Sass::Value::Function.new(nil).instance_eval do
               @id = obj.id
               self
             end