sass-embedded 0.18.2 → 0.19.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b9eeafb6dcad576b707936df8fe78e0de78712c7a1fb51c0adc372a83721d371
-  data.tar.gz: 5f1a354a8c9b08f37f6215c9d9a53582b0eef7e48f62c84d910671ae960b2677
+  metadata.gz: 573a157ee6e0c3fa51cefec5c011649717718133d934e031a339d32a84838a13
+  data.tar.gz: ef27dd3177b8f58f3dd19180340686901597e9ac05efa77e2f9cc12b7784dbbb
 SHA512:
-  metadata.gz: 50ac1de6a47ac9becebe4f229ffd6befbc25a0a481a4551e88fc600ff8934f554ab1ecc35bee8e68847d5d2315058d9a21a4952cd4ee86b3ccf011c21ec62ed9
-  data.tar.gz: daa53389ab4d49e5d8a6189eaf4391a978a640444b79279b401beac6070086db4903786b4df9d6ee9a0216a4391e3f4cb32a9be2c1c25c4ec9eae3a145f065c1
+  metadata.gz: 538de1728de2da841ce66648d669acec38a4a3c3f15357e5d33e1d5dac773f246b43f29d244ec39076fc3d18504f6935374f9a5277baac7a1c400548b44aef5b
+  data.tar.gz: 26db551dd98592327a0c7e4fc9ee39c5917b1aff92431bfc7cdac6eea3c79899439c976512c7bed393493f564fd00e0ccafe735fe8cd8a514827d7a42b689d58

data/lib/sass/compile_error.rb

@@ -12,7 +12,7 @@ module Sass
       @span = span
     end
 
-    def full_message(*_args, **_kwargs)
+    def full_message(*)
       if @full_message.nil?
         super
       else

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(*args)
-        @observerable_mutex.synchronize do
-          raise ProtocolError, 'half-closed compiler' if half_closed?
-
-          super(*args)
-
-          id = @id
-          @id = @id.next
-          id
-        end
-      end
-
-      def delete_observer(*args)
-        @observerable_mutex.synchronize do
-          super(*args)
-
-          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,90 @@
+# 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.store(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
+          @observers[message.compilation_id]&.send(outbound_message.message, message)
+        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,23 +2,27 @@
 
 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
                        .map { |importer| register(importer) }
-                       .concat(load_paths.map do |load_path|
-                                 EmbeddedProtocol::InboundMessage::CompileRequest::Importer.new(
-                                   path: File.absolute_path(load_path)
-                                 )
-                               end)
+                       .concat(
+                         load_paths.map do |load_path|
+                           EmbeddedProtocol::InboundMessage::CompileRequest::Importer.new(
+                             path: File.absolute_path(load_path)
+                           )
+                         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
 
@@ -15,23 +17,26 @@ module Sass
           case event.type
           when :DEBUG
             if logger.respond_to? :debug
-              logger.debug(event.message, span: Protofier.from_proto_source_span(event.span))
+              logger.debug(event.message,
+                           span: Protofier.from_proto_source_span(event.span))
             else
               warn(event.formatted)
             end
           when :DEPRECATION_WARNING
             if logger.respond_to? :warn
-              logger.warn(event.message, deprecation: true,
-                                         span: Protofier.from_proto_source_span(event.span),
-                                         stack: event.stack_trace)
+              logger.warn(event.message,
+                          deprecation: true,
+                          span: Protofier.from_proto_source_span(event.span),
+                          stack: event.stack_trace)
             else
               warn(event.formatted)
             end
           when :WARNING
             if logger.respond_to? :warn
-              logger.warn(event.message, deprecation: false,
-                                         span: Protofier.from_proto_source_span(event.span),
-                                         stack: event.stack_trace)
+              logger.warn(event.message,
+                          deprecation: false,
+                          span: Protofier.from_proto_source_span(event.span),
+                          stack: event.stack_trace)
             else
               warn(event.formatted)
             end

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
@@ -122,8 +124,8 @@ module Sass
           when :number
             Sass::Value::Number.new(
               obj.value,
-              obj.numerators,
-              obj.denominators
+              obj.numerators.to_a,
+              obj.denominators.to_a
             )
           when :rgb_color
             Sass::Value::Color.new(

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:)
+        async 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
+        async 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 async
+        @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

@@ -40,7 +40,6 @@ module Sass
     # @example
     #   Sass.render(file: 'style.css')
     # @return [Result]
-    # @raise [ProtocolError]
     # @raise [RenderError]
     def render(**kwargs)
       instance.render(**kwargs)
@@ -71,7 +70,6 @@ module Sass
     # See {file:README.md#options} for supported options.
     #
     # @return [RenderResult]
-    # @raise [ProtocolError]
     # @raise [RenderError]
     def render(data: nil,
                file: nil,