sass-embedded 0.18.4 → 0.19.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 25068693aab079cc3ec673b99407a0b9edfcf905c8afea7985ee06f9bbc3bb87
-  data.tar.gz: 6af725ccc88495167bf0704d6a1789355e6d0a85280176342499e92e965cc35c
+  metadata.gz: 827e324d735fe63938d7ddeb8d13c31577d9eec28971561bf6eae4cca7013eeb
+  data.tar.gz: b8536a68113173ca68edecca565ef7f4e13aba5a647902f0dd4d1411c2127380
 SHA512:
-  metadata.gz: 577d34e39cf3adb245f39bf49ea2e621558e9d8714dc39efa8a4584f8728aed5ddb944251c9d82ffcc101d4e4788f795cade2e70a5729e84b9628a10538e22ab
-  data.tar.gz: 3d4b4a936b6fe3d5bcb200e54e990ddb15cc668b98b6cb11db4ee93058ad469c77879dceae45dd2ba32c6bc6902b0adee120b8fb71a4908f391fc4bb0faafb68
+  metadata.gz: 9c16c31eec049d62c380049e2b565fcb1d05c55205f3f5966b43b47fd058d1c0fffc959f178ed68b47465cbd0c152b355c8196912a3688ba01a2c5783a2b9719
+  data.tar.gz: 4d4836379db8fa44061bf92c49c2a49dcb76f0299fad42df56c8c4d59ce0babf66d8245f3c73e36b51a6f58062050e9bff8bccbfb5356a8b87b40329abcb1f41

data/ext/sass/extconf.rb

@@ -215,9 +215,11 @@ module Sass
       def default_sass_embedded_protocol
         repo = 'sass/embedded-protocol'
 
-        tag_name = IO.popen([Compiler::PATH, '--version']) do |file|
-          JSON.parse(file.read)['protocolVersion']
-        end
+        stdout, stderr, status = Open3.capture3(Compiler::PATH, '--version')
+
+        raise stderr unless status.success?
+
+        tag_name = JSON.parse(stdout)['protocolVersion']
 
         "https://raw.githubusercontent.com/#{repo}/#{tag_name}/embedded_sass.proto"
       end

data/lib/sass/embedded/async.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module Sass
+  class Embedded
+    # The {Async} class.
+    #
+    # It awaits until the promise is resolved or rejected.
+    class Async
+      module State
+        PENDING = 0
+        FULFILLED = 1
+        REJECTED = 2
+      end
+
+      private_constant :State
+
+      def initialize
+        @error = nil
+        @result = nil
+        @state = State::PENDING
+
+        @condition_variable = ConditionVariable.new
+        @mutex = Mutex.new
+
+        begin
+          yield if block_given?
+        rescue StandardError => e
+          reject e
+        end
+      end
+
+      def resolve(value)
+        @mutex.synchronize do
+          return unless @state == State::PENDING
+
+          @state = State::FULFILLED
+          @result = value
+          @condition_variable.broadcast
+        end
+      end
+
+      def reject(reason)
+        @mutex.synchronize do
+          return unless @state == State::PENDING
+
+          @state = State::REJECTED
+          @error = reason
+          @condition_variable.broadcast
+        end
+      end
+
+      def await
+        @mutex.synchronize do
+          @condition_variable.wait(@mutex) if @state == State::PENDING
+
+          raise @error if @state == State::REJECTED
+
+          @result
+        end
+      end
+    end
+
+    private_constant :Async
+  end
+end

data/lib/sass/embedded/channel.rb

@@ -2,59 +2,58 @@
 
 module Sass
   class Embedded
-    # The {Channel} for {Compiler} calls. Each instance creates its own
-    # {Compiler}. A new {Compiler} is automatically created when the existing
-    # {Compiler} runs out of unique request id.
+    # The {Channel} class.
+    #
+    # It establishes connection between {Host} and {Dispatcher}.
     class Channel
       def initialize
         @mutex = Mutex.new
-        @compiler = Compiler.new
+        @dispatcher = Dispatcher.new
       end
 
       def close
         @mutex.synchronize do
-          @compiler.close
+          @dispatcher.close
         end
       end
 
       def closed?
         @mutex.synchronize do
-          @compiler.closed?
+          @dispatcher.closed?
         end
       end
 
-      def subscribe(observer)
+      def connect(observer)
         @mutex.synchronize do
           begin
-            id = @compiler.add_observer(observer)
-          rescue ProtocolError
-            @compiler = Compiler.new
-            id = @compiler.add_observer(observer)
+            id = @dispatcher.subscribe(observer)
+          rescue EOFError
+            @dispatcher = Dispatcher.new
+            id = @dispatcher.subscribe(observer)
           end
-          Subscription.new @compiler, observer, id
+          Connection.new(@dispatcher, id)
         end
       end
 
-      # The {Subscription} between {Compiler} and {Observer}.
-      class Subscription
+      # The {Connection} between {Host} to {Dispatcher}.
+      class Connection
         attr_reader :id
 
-        def initialize(compiler, observer, id)
-          @compiler = compiler
-          @observer = observer
+        def initialize(dispatcher, id)
+          @dispatcher = dispatcher
           @id = id
         end
 
-        def unsubscribe
-          @compiler.delete_observer(@observer)
+        def disconnect
+          @dispatcher.unsubscribe(id)
         end
 
-        def send_message(*args)
-          @compiler.send_message(*args)
+        def send_message(message)
+          @dispatcher.send_message(message)
         end
       end
 
-      private_constant :Subscription
+      private_constant :Connection
     end
 
     private_constant :Channel

data/lib/sass/embedded/compiler.rb

@@ -1,65 +1,34 @@
 # frozen_string_literal: true
 
-require 'observer'
 require 'open3'
 
 module Sass
   class Embedded
-    # The {::Observable} {Compiler} for low level communication with
-    # `dart-sass-embedded` using protocol buffers via stdio. Received messages
-    # can be observed by an {Observer}.
+    # The {Compiler} class.
+    #
+    # It runs the `dart-sass-embedded` process.
     class Compiler
-      include Observable
-
       PATH = File.absolute_path(
         "../../../ext/sass/sass_embedded/dart-sass-embedded#{Gem.win_platform? ? '.bat' : ''}", __dir__
       )
 
-      PROTOCOL_ERROR_ID = 4_294_967_295
-
       def initialize
-        @observerable_mutex = Mutex.new
-        @id = 0
         @stdin_mutex = Mutex.new
+        @stdout_mutex = Mutex.new
         @stdin, @stdout, @stderr, @wait_thread = Open3.popen3(PATH)
 
         [@stdin, @stdout].each(&:binmode)
 
-        poll do
-          warn(@stderr.readline, uplevel: 1)
-        end
-        poll do
-          receive_message Protofier.from_proto_message read
-        end
-      end
-
-      def add_observer(*)
-        @observerable_mutex.synchronize do
-          raise ProtocolError, 'half-closed compiler' if half_closed?
-
-          super
-
-          id = @id
-          @id = @id.next
-          id
-        end
-      end
-
-      def delete_observer(*)
-        @observerable_mutex.synchronize do
-          super
-
-          close if half_closed? && count_observers.zero?
+        Thread.new do
+          loop do
+            warn(@stderr.readline, uplevel: 1)
+          rescue IOError
+            break
+          end
         end
       end
 
-      def send_message(message)
-        write Protofier.to_proto_message message
-      end
-
       def close
-        delete_observers
-
         @stdin_mutex.synchronize do
           @stdin.close unless @stdin.closed?
           @stdout.close unless @stdout.closed?
@@ -75,54 +44,19 @@ module Sass
         end
       end
 
-      private
-
-      def half_closed?
-        @id == PROTOCOL_ERROR_ID
-      end
-
-      def poll
-        Thread.new do
-          loop do
-            yield
-          rescue StandardError
-            break
-          end
-        end
-      end
-
-      def notify_observers(*args)
-        @observerable_mutex.synchronize do
-          changed
-          super(*args)
-        end
-      end
-
-      def receive_message(message)
-        case message
-        when EmbeddedProtocol::ProtocolError
-          notify_observers(ProtocolError.new(message.message), nil)
-          close
-        else
-          notify_observers(nil, message)
-        end
-      end
-
-      def read
-        length = Varint.read(@stdout)
-        @stdout.read(length)
-      rescue IOError => e
-        notify_observers(e, nil)
-        close
-        raise e
-      end
-
       def write(payload)
         @stdin_mutex.synchronize do
           Varint.write(@stdin, payload.length)
           @stdin.write(payload)
         end
       end
+
+      def read
+        @stdout_mutex.synchronize do
+          length = Varint.read(@stdout)
+          @stdout.read(length)
+        end
+      end
     end
 
     private_constant :Compiler

data/lib/sass/embedded/dispatcher.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+module Sass
+  class Embedded
+    # The {Dispatcher} class.
+    #
+    # It dispatches messages between mutliple instances of {Host} and a single {Compiler}.
+    class Dispatcher
+      PROTOCOL_ERROR_ID = 4_294_967_295
+
+      def initialize
+        @compiler = Compiler.new
+        @observers = {}
+        @id = 0
+        @mutex = Mutex.new
+
+        Thread.new do
+          loop do
+            receive_message EmbeddedProtocol::OutboundMessage.decode @compiler.read
+          rescue IOError => e
+            half_close
+            @observers.each_value do |observer|
+              observer.error e
+            end
+            break
+          end
+        end
+      end
+
+      def subscribe(observer)
+        @mutex.synchronize do
+          raise EOFError if half_closed?
+
+          id = @id
+          @id = id.next
+          @observers[id] = observer
+          id
+        end
+      end
+
+      def unsubscribe(id)
+        @observers.delete(id)
+
+        close if half_closed? && @observers.empty?
+      end
+
+      def close
+        @compiler.close
+      end
+
+      def closed?
+        @compiler.closed?
+      end
+
+      def send_message(inbound_message)
+        @compiler.write(inbound_message.to_proto)
+      end
+
+      private
+
+      def half_close
+        @mutex.synchronize do
+          @id = PROTOCOL_ERROR_ID
+        end
+      end
+
+      def half_closed?
+        @id == PROTOCOL_ERROR_ID
+      end
+
+      def receive_message(outbound_message)
+        message = outbound_message.send(outbound_message.message)
+
+        case outbound_message.message
+        when :error
+          half_close
+          @observers[message.id]&.send(outbound_message.message, message)
+        when :compile_response, :version_response
+          @observers[message.id].send(outbound_message.message, message)
+        when :log_event, :canonicalize_request, :import_request, :file_import_request, :function_call_request
+          Thread.new(@observers[message.compilation_id]) do |observer|
+            observer.send(outbound_message.message, message)
+          end
+        else
+          raise ArgumentError, "Unknown OutboundMessage.message #{message}"
+        end
+      end
+    end
+
+    private_constant :Dispatcher
+  end
+end

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

@@ -2,12 +2,14 @@
 
 module Sass
   class Embedded
-    class CompileContext
-      # The {FunctionRegistry} for {CompileContext}.
+    class Host
+      # The {FunctionRegistry} class.
+      #
+      # It stores sass custom functions and handles function calls.
       class FunctionRegistry
         attr_reader :global_functions
 
-        def initialize(functions, highlight:)
+        def initialize(functions, alert_color:)
           functions = functions.transform_keys(&:to_s)
 
           @global_functions = functions.keys
@@ -25,7 +27,7 @@ module Sass
           @functions_by_id = {}
           @ids_by_function = {}
 
-          @highlight = highlight
+          @highlight = alert_color
         end
 
         def register(function)

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

@@ -2,12 +2,14 @@
 
 module Sass
   class Embedded
-    class CompileContext
-      # The {ImporterRegistry} for {CompileContext}.
+    class Host
+      # The {ImporterRegistry} class.
+      #
+      # It stores importers and handles import requests.
       class ImporterRegistry
         attr_reader :importers
 
-        def initialize(importers, load_paths, highlight:)
+        def initialize(importers, load_paths, alert_color:)
           @id = 0
           @importers_by_id = {}
           @importers = importers
@@ -20,7 +22,7 @@ module Sass
                          end
                        )
 
-          @highlight = highlight
+          @highlight = alert_color
         end
 
         def register(importer)

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

@@ -2,8 +2,10 @@
 
 module Sass
   class Embedded
-    class CompileContext
-      # The {LoggerRegistry} for {CompileContext}.
+    class Host
+      # The {LoggerRegistry} class.
+      #
+      # It stores logger and handles log events.
       class LoggerRegistry
         attr_reader :logger
 

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

@@ -2,8 +2,10 @@
 
 module Sass
   class Embedded
-    class CompileContext
-      # The {ValueProtofier} between Pure Ruby types and Protobuf Ruby types.
+    class Host
+      # The {ValueProtofier} class.
+      #
+      # It converts Pure Ruby types and Protobuf Ruby types.
       class ValueProtofier
         def initialize(function_registry)
           @function_registry = function_registry

data/lib/sass/embedded/host.rb

@@ -0,0 +1,135 @@
+# frozen_string_literal: true
+
+module Sass
+  class Embedded
+    # The {Host} class.
+    #
+    # It communicates with {Dispatcher} and handles the host logic.
+    class Host
+      def initialize(channel)
+        @channel = channel
+        @mutex = Mutex.new
+      end
+
+      def id
+        @connection.id
+      end
+
+      def send_message(message)
+        @connection.send_message(message)
+      end
+
+      def compile_request(path:,
+                          source:,
+                          importer:,
+                          load_paths:,
+                          syntax:,
+                          url:,
+                          source_map:,
+                          source_map_include_sources:,
+                          style:,
+                          functions:,
+                          importers:,
+                          alert_ascii:,
+                          alert_color:,
+                          logger:,
+                          quiet_deps:,
+                          verbose:)
+        await do
+          @function_registry = FunctionRegistry.new(functions, alert_color: alert_color)
+          @importer_registry = ImporterRegistry.new(importers, load_paths, alert_color: alert_color)
+          @logger_registry = LoggerRegistry.new(logger)
+
+          send_message EmbeddedProtocol::InboundMessage.new(
+            compile_request: EmbeddedProtocol::InboundMessage::CompileRequest.new(
+              id: id,
+              string: unless source.nil?
+                        EmbeddedProtocol::InboundMessage::CompileRequest::StringInput.new(
+                          source: source,
+                          url: url&.to_s,
+                          syntax: Protofier.to_proto_syntax(syntax),
+                          importer: importer.nil? ? nil : @importer_registry.register(importer)
+                        )
+                      end,
+              path: path,
+              style: Protofier.to_proto_output_style(style),
+              source_map: source_map,
+              source_map_include_sources: source_map_include_sources,
+              importers: @importer_registry.importers,
+              global_functions: @function_registry.global_functions,
+              alert_ascii: alert_ascii,
+              alert_color: alert_color,
+              quiet_deps: quiet_deps,
+              verbose: verbose
+            )
+          )
+        end
+      end
+
+      def version_request
+        await do
+          send_message EmbeddedProtocol::InboundMessage.new(
+            version_request: EmbeddedProtocol::InboundMessage::VersionRequest.new(
+              id: id
+            )
+          )
+        end
+      end
+
+      def log_event(message)
+        @logger_registry.log(message)
+      end
+
+      def compile_response(message)
+        @async.resolve(message)
+      end
+
+      def version_response(message)
+        @async.resolve(message)
+      end
+
+      def canonicalize_request(message)
+        send_message EmbeddedProtocol::InboundMessage.new(
+          canonicalize_response: @importer_registry.canonicalize(message)
+        )
+      end
+
+      def import_request(message)
+        send_message EmbeddedProtocol::InboundMessage.new(
+          import_response: @importer_registry.import(message)
+        )
+      end
+
+      def file_import_request(message)
+        send_message EmbeddedProtocol::InboundMessage.new(
+          file_import_response: @importer_registry.file_import(message)
+        )
+      end
+
+      def function_call_request(message)
+        send_message EmbeddedProtocol::InboundMessage.new(
+          function_call_response: @function_registry.function_call(message)
+        )
+      end
+
+      def error(message)
+        @async.reject(CompileError.new(message.message, nil, nil, nil))
+      end
+
+      private
+
+      def await
+        @mutex.synchronize do
+          @connection = @channel.connect(self)
+          @async = Async.new
+          yield
+          @async.await
+        ensure
+          @connection.disconnect
+        end
+      end
+    end
+
+    private_constant :Host
+  end
+end

data/lib/sass/embedded/legacy.rb

@@ -1,10 +1,5 @@
 # frozen_string_literal: true
 
-require 'base64'
-require 'json'
-require 'pathname'
-require 'uri'
-
 # The Sass module.
 #
 # This communicates with Embedded Dart Sass using the Embedded Sass protocol.
@@ -40,7 +35,6 @@ module Sass
     # @example
     #   Sass.render(file: 'style.css')
     # @return [Result]
-    # @raise [ProtocolError]
     # @raise [RenderError]
     def render(**kwargs)
       instance.render(**kwargs)
@@ -71,7 +65,6 @@ module Sass
     # See {file:README.md#options} for supported options.
     #
     # @return [RenderResult]
-    # @raise [ProtocolError]
     # @raise [RenderError]
     def render(data: nil,
                file: nil,
@@ -89,10 +82,13 @@ module Sass
                source_map_root: '',
                functions: {},
                importer: [])
-      start = now
-
       raise ArgumentError, 'either data or file must be set' if file.nil? && data.nil?
 
+      require 'pathname'
+      require 'uri'
+
+      start = now
+
       indent_type = parse_indent_type(indent_type)
       indent_width = parse_indent_width(indent_width)
       linefeed = parse_linefeed(linefeed)
@@ -219,6 +215,9 @@ module Sass
                          source_map_root:)
       return if map.nil? || map.empty?
 
+      require 'base64'
+      require 'json'
+
       map_data = JSON.parse(map)
 
       map_data['sourceRoot'] = source_map_root