sass-embedded 0.18.4 → 0.19.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 25068693aab079cc3ec673b99407a0b9edfcf905c8afea7985ee06f9bbc3bb87
-  data.tar.gz: 6af725ccc88495167bf0704d6a1789355e6d0a85280176342499e92e965cc35c
+  metadata.gz: 573a157ee6e0c3fa51cefec5c011649717718133d934e031a339d32a84838a13
+  data.tar.gz: ef27dd3177b8f58f3dd19180340686901597e9ac05efa77e2f9cc12b7784dbbb
 SHA512:
-  metadata.gz: 577d34e39cf3adb245f39bf49ea2e621558e9d8714dc39efa8a4584f8728aed5ddb944251c9d82ffcc101d4e4788f795cade2e70a5729e84b9628a10538e22ab
-  data.tar.gz: 3d4b4a936b6fe3d5bcb200e54e990ddb15cc668b98b6cb11db4ee93058ad469c77879dceae45dd2ba32c6bc6902b0adee120b8fb71a4908f391fc4bb0faafb68
+  metadata.gz: 538de1728de2da841ce66648d669acec38a4a3c3f15357e5d33e1d5dac773f246b43f29d244ec39076fc3d18504f6935374f9a5277baac7a1c400548b44aef5b
+  data.tar.gz: 26db551dd98592327a0c7e4fc9ee39c5917b1aff92431bfc7cdac6eea3c79899439c976512c7bed393493f564fd00e0ccafe735fe8cd8a514827d7a42b689d58

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,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,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:)
+        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,

data/lib/sass/embedded/protofier.rb

@@ -2,17 +2,10 @@
 
 module Sass
   class Embedded
-    # The {Protofier} between Pure Ruby types and Protobuf Ruby types.
+    # The {Protofier} module.
+    #
+    # It converts Pure Ruby types and Protobuf Ruby types.
     module Protofier
-      ONEOF_MESSAGE = EmbeddedProtocol::InboundMessage
-                      .descriptor
-                      .lookup_oneof('message')
-                      .to_h do |field_descriptor|
-        [field_descriptor.subtype, field_descriptor.name]
-      end
-
-      private_constant :ONEOF_MESSAGE
-
       module_function
 
       def from_proto_compile_response(compile_response)
@@ -50,17 +43,6 @@ module Sass
                                    source_location.column)
       end
 
-      def from_proto_message(proto)
-        message = EmbeddedProtocol::OutboundMessage.decode(proto)
-        message.send(message.message)
-      end
-
-      def to_proto_message(message)
-        EmbeddedProtocol::InboundMessage.new(
-          ONEOF_MESSAGE[message.class.descriptor] => message
-        ).to_proto
-      end
-
       def to_proto_syntax(syntax)
         case syntax&.to_sym
         when :scss

data/lib/sass/embedded/structifier.rb

@@ -2,7 +2,9 @@
 
 module Sass
   class Embedded
-    # The {Structifier} that convert {::Hash} to {Struct}-like object.
+    # The {Structifier} module.
+    #
+    # It converts {::Hash} to {Struct}-like objects.
     module Structifier
       module_function
 

data/lib/sass/embedded/varint.rb

@@ -2,7 +2,9 @@
 
 module Sass
   class Embedded
-    # Read and write {Varint} from {::IO}.
+    # The {Varint} module.
+    #
+    # It reads and writes varints.
     module Varint
       module_function
 

data/lib/sass/embedded/version.rb

@@ -2,6 +2,6 @@
 
 module Sass
   class Embedded
-    VERSION = '0.18.4'
+    VERSION = '0.19.0'
   end
 end

data/lib/sass/embedded.rb

@@ -18,7 +18,6 @@ module Sass
     #
     # @return [CompileResult]
     # @raise [CompileError]
-    # @raise [ProtocolError]
     def compile(path,
                 load_paths: [],
 
@@ -38,23 +37,24 @@ module Sass
       raise ArgumentError, 'path must be set' if path.nil?
 
       Protofier.from_proto_compile_response(
-        CompileContext.new(@channel,
-                           path: path,
-                           source: nil,
-                           importer: nil,
-                           load_paths: load_paths,
-                           syntax: nil,
-                           url: nil,
-                           source_map: source_map,
-                           source_map_include_sources: source_map_include_sources,
-                           style: style,
-                           functions: functions,
-                           importers: importers,
-                           alert_color: alert_color,
-                           alert_ascii: alert_ascii,
-                           logger: logger,
-                           quiet_deps: quiet_deps,
-                           verbose: verbose).receive_message
+        Host.new(@channel).compile_request(
+          path: path,
+          source: nil,
+          importer: nil,
+          load_paths: load_paths,
+          syntax: nil,
+          url: nil,
+          source_map: source_map,
+          source_map_include_sources: source_map_include_sources,
+          style: style,
+          functions: functions,
+          importers: importers,
+          alert_color: alert_color,
+          alert_ascii: alert_ascii,
+          logger: logger,
+          quiet_deps: quiet_deps,
+          verbose: verbose
+        )
       )
     end
 
@@ -62,7 +62,6 @@ module Sass
     #
     # @return [CompileResult]
     # @raise [CompileError]
-    # @raise [ProtocolError]
     def compile_string(source,
                        importer: nil,
                        load_paths: [],
@@ -84,31 +83,30 @@ module Sass
       raise ArgumentError, 'source must be set' if source.nil?
 
       Protofier.from_proto_compile_response(
-        CompileContext.new(@channel,
-                           path: nil,
-                           source: source,
-                           importer: importer,
-                           load_paths: load_paths,
-                           syntax: syntax,
-                           url: url,
-                           source_map: source_map,
-                           source_map_include_sources: source_map_include_sources,
-                           style: style,
-                           functions: functions,
-                           importers: importers,
-                           alert_color: alert_color,
-                           alert_ascii: alert_ascii,
-                           logger: logger,
-                           quiet_deps: quiet_deps,
-                           verbose: verbose).receive_message
+        Host.new(@channel).compile_request(
+          path: nil,
+          source: source,
+          importer: importer,
+          load_paths: load_paths,
+          syntax: syntax,
+          url: url,
+          source_map: source_map,
+          source_map_include_sources: source_map_include_sources,
+          style: style,
+          functions: functions,
+          importers: importers,
+          alert_color: alert_color,
+          alert_ascii: alert_ascii,
+          logger: logger,
+          quiet_deps: quiet_deps,
+          verbose: verbose
+        )
       )
     end
 
     # The {Embedded#info} method.
-    #
-    # @raise [ProtocolError]
     def info
-      @info ||= "sass-embedded\t#{VersionContext.new(@channel).receive_message.implementation_version}"
+      @info ||= "sass-embedded\t#{Host.new(@channel).version_request.implementation_version}"
     end
 
     def close

data/lib/sass/value/argument_list.rb

@@ -1,12 +1,12 @@
 # frozen_string_literal: true
 
 module Sass
-  class Value
+  module Value
     # Sass's argument list type.
     #
     # An argument list comes from a rest argument. It's distinct from a normal {List} in that it may contain a keyword
     # map as well as the positional arguments.
-    class ArgumentList < Sass::Value::List
+    class ArgumentList < Value::List
       def initialize(contents = [], keywords = {}, separator = ',')
         super(contents, separator: separator)
 

data/lib/sass/value/boolean.rb

@@ -1,10 +1,12 @@
 # frozen_string_literal: true
 
 module Sass
-  class Value
+  module Value
     # Sass's boolean type.
-    class Boolean < Sass::Value
-      def initialize(value) # rubocop:disable Lint/MissingSuper
+    class Boolean
+      include Value
+
+      def initialize(value)
         @value = value
       end
 

data/lib/sass/value/color.rb

@@ -1,14 +1,21 @@
 # frozen_string_literal: true
 
 module Sass
-  class Value
+  module Value
     # Sass's color type.
     #
     # No matter what representation was originally used to create this color, all of its channels are accessible.
-    class Color < Sass::Value
-      def initialize(red: nil, green: nil, blue: nil, # rubocop:disable Lint/MissingSuper
-                     hue: nil, saturation: nil, lightness: nil,
-                     whiteness: nil, blackness: nil,
+    class Color
+      include Value
+
+      def initialize(red: nil,
+                     green: nil,
+                     blue: nil,
+                     hue: nil,
+                     saturation: nil,
+                     lightness: nil,
+                     whiteness: nil,
+                     blackness: nil,
                      alpha: nil)
         @alpha = alpha.nil? ? 1 : FuzzyMath.assert_between(alpha, 0, 1, 'alpha')
         if red && green && blue

data/lib/sass/value/function.rb

@@ -1,10 +1,12 @@
 # frozen_string_literal: true
 
 module Sass
-  class Value
+  module Value
     # Sass's function type.
-    class Function < Sass::Value
-      def initialize(id_or_signature, callback = nil) # rubocop:disable Lint/MissingSuper
+    class Function
+      include Value
+
+      def initialize(id_or_signature, callback = nil)
         if id_or_signature.is_a? Numeric
           @id = id_or_signature
         else

data/lib/sass/value/fuzzy_math.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module Sass
-  class Value
+  module Value
     # Sass's {FuzzyMath} module.
     module FuzzyMath
       PRECISION = 10

data/lib/sass/value/list.rb

@@ -1,10 +1,12 @@
 # frozen_string_literal: true
 
 module Sass
-  class Value
+  module Value
     # Sass's list type.
-    class List < Sass::Value
-      def initialize(contents = [], separator: ',', bracketed: false) # rubocop:disable Lint/MissingSuper
+    class List
+      include Value
+
+      def initialize(contents = [], separator: ',', bracketed: false)
         if separator.nil? && contents.length > 1
           raise error 'A list with more than one element must have an explicit separator'
         end

data/lib/sass/value/map.rb

@@ -1,10 +1,12 @@
 # frozen_string_literal: true
 
 module Sass
-  class Value
+  module Value
     # Sass's map type.
-    class Map < Sass::Value
-      def initialize(contents = {}) # rubocop:disable Lint/MissingSuper
+    class Map
+      include Value
+
+      def initialize(contents = {})
         @contents = contents.freeze
       end
 

data/lib/sass/value/null.rb

@@ -1,10 +1,12 @@
 # frozen_string_literal: true
 
 module Sass
-  class Value
+  module Value
     # Sass's null type.
-    class Null < Sass::Value
-      def initialize # rubocop:disable Lint/MissingSuper
+    class Null
+      include Value
+
+      def initialize
         @value = nil
       end
 

data/lib/sass/value/number/unit.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module Sass
-  class Value
+  module Value
     class Number
       # The {Unit} module.
       module Unit

data/lib/sass/value/number.rb

@@ -1,10 +1,12 @@
 # frozen_string_literal: true
 
 module Sass
-  class Value
+  module Value
     # Sass's number type.
-    class Number < Sass::Value
-      def initialize(value, numerator_units = [], denominator_units = []) # rubocop:disable Lint/MissingSuper
+    class Number
+      include Value
+
+      def initialize(value, numerator_units = [], denominator_units = [])
         numerator_units = [numerator_units] if numerator_units.is_a?(::String)
         denominator_units = [denominator_units] if denominator_units.is_a?(::String)
 

data/lib/sass/value/string.rb

@@ -1,10 +1,12 @@
 # frozen_string_literal: true
 
 module Sass
-  class Value
+  module Value
     # Sass's string type.
-    class String < Sass::Value
-      def initialize(text = '', quoted: true) # rubocop:disable Lint/MissingSuper
+    class String
+      include Value
+
+      def initialize(text = '', quoted: true)
         @text = text.freeze
         @quoted = quoted
       end

data/lib/sass/value.rb

@@ -2,7 +2,7 @@
 
 module Sass
   # The abstract base class of Sass's value types.
-  class Value
+  module Value
     def to_a
       [self]
     end

data/lib/sass.rb

@@ -3,22 +3,21 @@
 require_relative 'sass/compile_error'
 require_relative 'sass/compile_result'
 require_relative 'sass/embedded'
+require_relative 'sass/embedded/async'
 require_relative 'sass/embedded/channel'
-require_relative 'sass/embedded/observer'
-require_relative 'sass/embedded/compile_context'
-require_relative 'sass/embedded/compile_context/function_registry'
-require_relative 'sass/embedded/compile_context/importer_registry'
-require_relative 'sass/embedded/compile_context/logger_registry'
-require_relative 'sass/embedded/compile_context/value_protofier'
 require_relative 'sass/embedded/compiler'
-require_relative 'sass/embedded_protocol'
+require_relative 'sass/embedded/dispatcher'
+require_relative 'sass/embedded/host'
+require_relative 'sass/embedded/host/function_registry'
+require_relative 'sass/embedded/host/importer_registry'
+require_relative 'sass/embedded/host/logger_registry'
+require_relative 'sass/embedded/host/value_protofier'
 require_relative 'sass/embedded/legacy'
-require_relative 'sass/embedded/protocol_error'
 require_relative 'sass/embedded/protofier'
 require_relative 'sass/embedded/structifier'
 require_relative 'sass/embedded/varint'
 require_relative 'sass/embedded/version'
-require_relative 'sass/embedded/version_context'
+require_relative 'sass/embedded_protocol'
 require_relative 'sass/logger'
 require_relative 'sass/logger/source_location'
 require_relative 'sass/logger/source_span'
@@ -51,7 +50,6 @@ module Sass
     #   Sass.compile('style.scss')
     # @return [CompileResult]
     # @raise [CompileError]
-    # @raise [Embedded::ProtocolError]
     def compile(path, **kwargs)
       instance.compile(path, **kwargs)
     end
@@ -66,7 +64,6 @@ module Sass
     #   Sass.compile_string('h1 { font-size: 40px; }')
     # @return [CompileResult]
     # @raise [CompileError]
-    # @raise [Embedded::ProtocolError]
     def compile_string(source, **kwargs)
       instance.compile_string(source, **kwargs)
     end
@@ -74,8 +71,6 @@ module Sass
     # The global {.info} method.
     #
     # This instantiates a global {Embedded} instance and calls {Embedded#info}.
-    #
-    # @raise [Embedded::ProtocolError]
     def info
       instance.info
     end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sass-embedded
 version: !ruby/object:Gem::Version
-  version: 0.18.4
+  version: 0.19.0
 platform: ruby
 authors:
 - なつき
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2022-02-21 00:00:00.000000000 Z
+date: 2022-02-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: google-protobuf
@@ -128,21 +128,20 @@ files:
 - lib/sass/compile_error.rb
 - lib/sass/compile_result.rb
 - lib/sass/embedded.rb
+- lib/sass/embedded/async.rb
 - lib/sass/embedded/channel.rb
-- lib/sass/embedded/compile_context.rb
-- lib/sass/embedded/compile_context/function_registry.rb
-- lib/sass/embedded/compile_context/importer_registry.rb
-- lib/sass/embedded/compile_context/logger_registry.rb
-- lib/sass/embedded/compile_context/value_protofier.rb
 - lib/sass/embedded/compiler.rb
+- lib/sass/embedded/dispatcher.rb
+- lib/sass/embedded/host.rb
+- lib/sass/embedded/host/function_registry.rb
+- lib/sass/embedded/host/importer_registry.rb
+- lib/sass/embedded/host/logger_registry.rb
+- lib/sass/embedded/host/value_protofier.rb
 - lib/sass/embedded/legacy.rb
-- lib/sass/embedded/observer.rb
-- lib/sass/embedded/protocol_error.rb
 - lib/sass/embedded/protofier.rb
 - lib/sass/embedded/structifier.rb
 - lib/sass/embedded/varint.rb
 - lib/sass/embedded/version.rb
-- lib/sass/embedded/version_context.rb
 - lib/sass/embedded_protocol.rb
 - lib/sass/logger.rb
 - lib/sass/logger/source_location.rb
@@ -164,8 +163,8 @@ homepage: https://github.com/ntkme/sass-embedded-host-ruby
 licenses:
 - MIT
 metadata:
-  documentation_uri: https://www.rubydoc.info/gems/sass-embedded/0.18.4
-  source_code_uri: https://github.com/ntkme/sass-embedded-host-ruby/tree/v0.18.4
+  documentation_uri: https://www.rubydoc.info/gems/sass-embedded/0.19.0
+  source_code_uri: https://github.com/ntkme/sass-embedded-host-ruby/tree/v0.19.0
   funding_uri: https://github.com/sponsors/ntkme
 post_install_message: 
 rdoc_options: []

data/lib/sass/embedded/compile_context.rb

@@ -1,107 +0,0 @@
-# frozen_string_literal: true
-
-module Sass
-  class Embedded
-    # The {Observer} for {Embedded#compile}.
-    class CompileContext
-      include Observer
-
-      def initialize(channel,
-                     path:,
-                     source:,
-
-                     importer:,
-                     load_paths:,
-                     syntax:,
-                     url:,
-
-                     source_map:,
-                     source_map_include_sources:,
-                     style:,
-
-                     functions:,
-                     importers:,
-
-                     alert_ascii:,
-                     alert_color:,
-                     logger:,
-                     quiet_deps:,
-                     verbose:)
-        @function_registery = FunctionRegistry.new(functions, highlight: alert_color)
-        @importer_registery = ImporterRegistry.new(importers, load_paths, highlight: alert_color)
-        @logger_registery = LoggerRegistry.new(logger)
-
-        super(channel)
-
-        send_message 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_registery.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_registery.importers,
-          global_functions: @function_registery.global_functions,
-          alert_ascii: alert_ascii,
-          alert_color: alert_color,
-          quiet_deps: quiet_deps,
-          verbose: verbose
-        )
-      end
-
-      def update(error, message)
-        raise error unless error.nil?
-
-        case message
-        when EmbeddedProtocol::OutboundMessage::CompileResponse
-          return unless message.id == id
-
-          Thread.new do
-            super(nil, message)
-          end
-        when EmbeddedProtocol::OutboundMessage::LogEvent
-          return unless message.compilation_id == id
-
-          @logger_registery.log message
-        when EmbeddedProtocol::OutboundMessage::CanonicalizeRequest
-          return unless message.compilation_id == id
-
-          Thread.new do
-            send_message @importer_registery.canonicalize message
-          end
-        when EmbeddedProtocol::OutboundMessage::ImportRequest
-          return unless message.compilation_id == id
-
-          Thread.new do
-            send_message @importer_registery.import message
-          end
-        when EmbeddedProtocol::OutboundMessage::FileImportRequest
-          return unless message.compilation_id == id
-
-          Thread.new do
-            send_message @importer_registery.file_import message
-          end
-        when EmbeddedProtocol::OutboundMessage::FunctionCallRequest
-          return unless message.compilation_id == id
-
-          Thread.new do
-            send_message @function_registery.function_call message
-          end
-        end
-      rescue StandardError => e
-        Thread.new do
-          super(e, nil)
-        end
-      end
-    end
-
-    private_constant :CompileContext
-  end
-end

data/lib/sass/embedded/observer.rb

@@ -1,49 +0,0 @@
-# frozen_string_literal: true
-
-module Sass
-  class Embedded
-    # The {Observer} module for communicating with {Compiler}.
-    module Observer
-      def initialize(channel)
-        @mutex = Mutex.new
-        @condition_variable = ConditionVariable.new
-        @error = nil
-        @message = nil
-
-        @subscription = channel.subscribe(self)
-      end
-
-      def receive_message
-        @mutex.synchronize do
-          @condition_variable.wait(@mutex) if @error.nil? && @message.nil?
-        end
-
-        raise @error unless @error.nil?
-
-        @message
-      end
-
-      def update(error, message)
-        @subscription.unsubscribe
-
-        @mutex.synchronize do
-          @error = error
-          @message = message
-          @condition_variable.broadcast
-        end
-      end
-
-      private
-
-      def id
-        @subscription.id
-      end
-
-      def send_message(*args)
-        @subscription.send_message(*args)
-      end
-    end
-
-    private_constant :Observer
-  end
-end

data/lib/sass/embedded/protocol_error.rb

@@ -1,7 +0,0 @@
-# frozen_string_literal: true
-
-module Sass
-  class Embedded
-    class ProtocolError < StandardError; end
-  end
-end

data/lib/sass/embedded/version_context.rb

@@ -1,35 +0,0 @@
-# frozen_string_literal: true
-
-module Sass
-  class Embedded
-    # The {Observer} for {Embedded#info}.
-    class VersionContext
-      include Observer
-
-      def initialize(channel)
-        super(channel)
-
-        send_message EmbeddedProtocol::InboundMessage::VersionRequest.new(id: id)
-      end
-
-      def update(error, message)
-        raise error unless error.nil?
-
-        case message
-        when EmbeddedProtocol::OutboundMessage::VersionResponse
-          return unless message.id == id
-
-          Thread.new do
-            super(nil, message)
-          end
-        end
-      rescue StandardError => e
-        Thread.new do
-          super(e, nil)
-        end
-      end
-    end
-
-    private_constant :VersionContext
-  end
-end