sass-embedded 0.1.3 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2c42f58b6f4f3200d3033fd59e65e7cd33132731ab4520bafb2a375cf55577ec
-  data.tar.gz: 2da13b64dab78a0b3fccd9a90cfcc6bd5affcd09dfe0b978aed53b69b2afa51e
+  metadata.gz: edeb1d7a1a3ba0d1485671e579478b4b1bc5d372350a25869cd4b0305bd2f356
+  data.tar.gz: 9eda21b2bdb2d7f278d03c9e5091eeec13956d9e0216ebb4a415988f8ac90b62
 SHA512:
-  metadata.gz: d484872bd432f0092e67f699b18af1e242c982ff0e2019f9d23340593744ca58a015f5d63c76ae83d0a29e05ed362a2015f8f55bdbe472da67488e99c1cdaa8f
-  data.tar.gz: bd452474519dabcd9d793205d8f0dcc64482a5313d48d9eda4464f0a5d6ed8b9d6a34ea1c57e4a8f178beafb008b080481fd6059ab2f3ad53494e2acd272527b
+  metadata.gz: 2cc608b5597a0c820633f1dc386de5e9125b00ed99004c5237e0223d5a181d4782da4b2025983f86fad47409ef738e1a5954e810f35e9f443dd319035b2aa4dc
+  data.tar.gz: a45ad64a3670c8d6f2136a287773eed2f77abaeb6911173931af8570fa1edeeed53a747ebc747288dc5b1941c08eb9ddc5c410ede3c536c380dd3297e0bf8092

data/lib/sass.rb

@@ -4,8 +4,8 @@ module Sass
   # The global include_paths for Sass files. This is meant for plugins and
   # libraries to register the paths to their Sass stylesheets to that they may
   # be `@imported`. This include path is used by every instance of
-  # {Sass::Embedded::Compiler}. They are lower-precedence than any include
-  # paths passed in via the `:include_paths` option.
+  # {Sass::Embedded}. They are lower-precedence than any include paths passed
+  # in via the `:include_paths` option.
   #
   # If the `SASS_PATH` environment variable is set,
   # the initial value of `include_paths` will be initialized based on that.
@@ -24,13 +24,13 @@ module Sass
   end
 
   def self.render(options)
-    unless defined? @compiler
-      @compiler = Sass::Embedded::Compiler.new
+    unless defined? @embedded
+      @embedded = Sass::Embedded.new
       at_exit do
-        @compiler.close
+        @embedded.close
       end
     end
-    @compiler.render options
+    @embedded.render options
   end
 end
 
@@ -38,5 +38,5 @@ require_relative 'sass/version'
 require_relative 'sass/error'
 require_relative 'sass/platform'
 require_relative 'sass/util'
-require_relative 'sass/embedded/transport'
-require_relative 'sass/embedded/compiler'
+require_relative 'sass/transport'
+require_relative 'sass/embedded'

data/lib/sass/embedded.rb

@@ -0,0 +1,236 @@
+# frozen_string_literal: true
+
+module Sass
+  class Embedded
+    def initialize
+      @transport = Transport.new
+      @id_semaphore = Mutex.new
+      @id = 0
+    end
+
+    def render(options)
+      start = Sass::Util.now
+
+      raise Sass::NotRenderedError, 'Either :data or :file must be set.' if options[:file].nil? && options[:data].nil?
+
+      string = if options[:data]
+                 Sass::EmbeddedProtocol::InboundMessage::CompileRequest::StringInput.new(
+                   source: options[:data],
+                   url: options[:file] ? Sass::Util.file_uri(options[:file]) : 'stdin',
+                   syntax: options[:indented_syntax] == true ? Sass::EmbeddedProtocol::Syntax::INDENTED : Sass::EmbeddedProtocol::Syntax::SCSS
+                 )
+               end
+
+      path = options[:data] ? nil : options[:file]
+
+      style = case options[:output_style]&.to_sym
+              when :expanded, nil
+                Sass::EmbeddedProtocol::OutputStyle::EXPANDED
+              when :compressed
+                Sass::EmbeddedProtocol::OutputStyle::COMPRESSED
+              when :nested, :compact
+                raise Sass::UnsupportedValue, "#{options[:output_style]} is not a supported :output_style"
+              else
+                raise Sass::InvalidStyleError, "#{options[:output_style]} is not a valid :output_style"
+              end
+
+      source_map = options[:source_map].is_a?(String) || (options[:source_map] == true && !options[:out_file].nil?)
+
+      # 1. Loading a file relative to the file in which the @use or @import appeared.
+      # 2. Each custom importer.
+      # 3. Loading a file relative to the current working directory.
+      # 4. Each load path in includePaths
+      # 5. Each load path specified in the SASS_PATH environment variable, which should be semicolon-separated on Windows and colon-separated elsewhere.
+      importers = (if options[:importer]
+                     [
+                       Sass::EmbeddedProtocol::InboundMessage::CompileRequest::Importer.new(importer_id: 0)
+                     ]
+                   else
+                     []
+                   end).concat(
+                     (options[:include_paths] || []).concat(Sass.include_paths)
+                     .map do |include_path|
+                       Sass::EmbeddedProtocol::InboundMessage::CompileRequest::Importer.new(
+                         path: File.absolute_path(include_path)
+                       )
+                     end
+                   )
+
+      signatures = []
+      functions = {}
+      options[:functions]&.each do |signature, function|
+        signatures.push signature
+        functions[signature.to_s.split('(')[0].chomp] = function
+      end
+
+      compilation_id = next_id
+
+      compile_request = Sass::EmbeddedProtocol::InboundMessage::CompileRequest.new(
+        id: compilation_id,
+        string: string,
+        path: path,
+        style: style,
+        source_map: source_map,
+        importers: importers,
+        global_functions: options[:functions] ? signatures : [],
+        alert_color: true,
+        alert_ascii: true
+      )
+
+      response = @transport.send compile_request, compilation_id
+
+      file = options[:file] || 'stdin'
+      canonicalizations = {}
+      imports = {}
+
+      loop do
+        case response
+        when Sass::EmbeddedProtocol::OutboundMessage::CompileResponse
+          break
+        when Sass::EmbeddedProtocol::OutboundMessage::CanonicalizeRequest
+          url = Sass::Util.file_uri(File.absolute_path(response.url, File.dirname(file)))
+
+          if canonicalizations.key? url
+            canonicalizations[url].id = response.id
+          else
+            resolved = nil
+            options[:importer].each do |importer|
+              begin
+                resolved = importer.call response.url, file
+              rescue StandardError => e
+                resolved = e
+              end
+              break if resolved
+            end
+            if resolved.nil?
+              canonicalizations[url] = Sass::EmbeddedProtocol::InboundMessage::CanonicalizeResponse.new(
+                id: response.id,
+                url: url
+              )
+            elsif resolved.is_a? StandardError
+              canonicalizations[url] = Sass::EmbeddedProtocol::InboundMessage::CanonicalizeResponse.new(
+                id: response.id,
+                error: resolved.message
+              )
+            elsif resolved.key? :contents
+              canonicalizations[url] = Sass::EmbeddedProtocol::InboundMessage::CanonicalizeResponse.new(
+                id: response.id,
+                url: url
+              )
+              imports[url] = Sass::EmbeddedProtocol::InboundMessage::ImportResponse.new(
+                id: response.id,
+                success: Sass::EmbeddedProtocol::InboundMessage::ImportResponse::ImportSuccess.new(
+                  contents: resolved[:contents],
+                  syntax: Sass::EmbeddedProtocol::Syntax::SCSS,
+                  source_map_url: nil
+                )
+              )
+            elsif resolved.key? :file
+              canonicalized_url = Sass::Util.file_uri(resolved[:file])
+              canonicalizations[url] = Sass::EmbeddedProtocol::InboundMessage::CanonicalizeResponse.new(
+                id: response.id,
+                url: canonicalized_url
+              )
+              imports[canonicalized_url] = Sass::EmbeddedProtocol::InboundMessage::ImportResponse.new(
+                id: response.id,
+                success: Sass::EmbeddedProtocol::InboundMessage::ImportResponse::ImportSuccess.new(
+                  contents: File.read(resolved[:file]),
+                  syntax: Sass::EmbeddedProtocol::Syntax::SCSS,
+                  source_map_url: nil
+                )
+              )
+            else
+              canonicalizations[url] = Sass::EmbeddedProtocol::InboundMessage::CanonicalizeResponse.new(
+                id: response.id,
+                error: "Unexpected value returned from importer: #{resolved}"
+              )
+            end
+          end
+
+          response = @transport.send canonicalizations[url], compilation_id
+        when Sass::EmbeddedProtocol::OutboundMessage::ImportRequest
+          url = response.url
+
+          if imports.key? url
+            imports[url].id = response.id
+          else
+            imports[url] = Sass::EmbeddedProtocol::InboundMessage::ImportResponse.new(
+              id: response.id,
+              error: "Failed to import: #{url}"
+            )
+          end
+
+          response = @transport.send imports[url], compilation_id
+        when Sass::EmbeddedProtocol::OutboundMessage::FunctionCallRequest
+          begin
+            message = Sass::EmbeddedProtocol::InboundMessage::FunctionCallResponse.new(
+              id: response.id,
+              success: functions[response.name].call(*response.arguments)
+            )
+          rescue StandardError => e
+            message = Sass::EmbeddedProtocol::InboundMessage::FunctionCallResponse.new(
+              id: response.id,
+              error: e.message
+            )
+          end
+
+          response = @transport.send message, compilation_id
+        when Sass::EmbeddedProtocol::ProtocolError
+          raise Sass::ProtocolError, response.message
+        else
+          raise Sass::ProtocolError, "Unexpected packet received: #{response}"
+        end
+      end
+
+      if response.failure
+        raise Sass::CompilationError.new(
+          response.failure.message,
+          response.failure.formatted,
+          response.failure.span ? response.failure.span.url : nil,
+          response.failure.span ? response.failure.span.start.line + 1 : nil,
+          response.failure.span ? response.failure.span.start.column + 1 : nil,
+          1
+        )
+      end
+
+      finish = Sass::Util.now
+
+      {
+        css: response.success.css,
+        map: response.success.source_map,
+        stats: {
+          entry: options[:file] || 'data',
+          start: start,
+          end: finish,
+          duration: finish - start
+        }
+      }
+    end
+
+    def close
+      @transport.close
+    end
+
+    private
+
+    def info
+      version_response = @transport.send Sass::EmbeddedProtocol::InboundMessage::VersionRequest.new(
+        id: next_id
+      )
+      {
+        compiler_version: version_response.compiler_version,
+        protocol_version: version_response.protocol_version,
+        implementation_name: version_response.implementation_name,
+        implementation_version: version_response.implementation_version
+      }
+    end
+
+    def next_id
+      @id_semaphore.synchronize do
+        @id += 1
+        @id = 0 if @id == Transport::PROTOCOL_ERROR_ID
+        @id
+      end
+    end
+  end
+end

data/lib/sass/transport.rb

@@ -0,0 +1,138 @@
+# frozen_string_literal: true
+
+require 'open3'
+require 'observer'
+require_relative '../../ext/sass_embedded/embedded_sass_pb'
+
+module Sass
+  class Transport
+    include Observable
+
+    DART_SASS_EMBEDDED = File.absolute_path(
+      "../../ext/sass_embedded/sass_embedded/dart-sass-embedded#{Sass::Platform::OS == 'windows' ? '.bat' : ''}", __dir__
+    )
+
+    PROTOCOL_ERROR_ID = 4_294_967_295
+
+    def initialize
+      @stdin, @stdout, @stderr, @wait_thread = Open3.popen3(DART_SASS_EMBEDDED)
+      @stdin_semaphore = Mutex.new
+      @observerable_semaphore = Mutex.new
+
+      Thread.new do
+        loop do
+          bits = length = 0
+          loop do
+            byte = @stdout.readbyte
+            length += (byte & 0x7f) << bits
+            bits += 7
+            break if byte <= 0x7f
+          end
+          changed
+          payload = @stdout.read length
+          @observerable_semaphore.synchronize do
+            notify_observers nil, Sass::EmbeddedProtocol::OutboundMessage.decode(payload)
+          end
+        rescue Interrupt
+          break
+        rescue IOError => e
+          notify_observers e, nil
+          close
+          break
+        end
+      end
+
+      Thread.new do
+        loop do
+          warn @stderr.read
+        rescue Interrupt
+          break
+        rescue IOError => e
+          @observerable_semaphore.synchronize do
+            notify_observers e, nil
+          end
+          close
+          break
+        end
+      end
+    end
+
+    def send(req, id)
+      mutex = Mutex.new
+      resource = ConditionVariable.new
+
+      req_name = req.class.name.split('::').last.gsub(/\B(?=[A-Z])/, '_').downcase
+
+      message = Sass::EmbeddedProtocol::InboundMessage.new(req_name.to_sym => req)
+
+      error = nil
+      res = nil
+
+      @observerable_semaphore.synchronize do
+        MessageObserver.new self, id do |e, r|
+          mutex.synchronize do
+            error = e
+            res = r
+
+            resource.signal
+          end
+        end
+      end
+
+      mutex.synchronize do
+        write message.to_proto
+
+        resource.wait(mutex)
+      end
+
+      raise error if error
+
+      res
+    end
+
+    def close
+      delete_observers
+      @stdin.close unless @stdin.closed?
+      @stdout.close unless @stdout.closed?
+      @stderr.close unless @stderr.closed?
+    end
+
+    private
+
+    def write(proto)
+      @stdin_semaphore.synchronize do
+        length = proto.length
+        while length.positive?
+          @stdin.write ((length > 0x7f ? 0x80 : 0) | (length & 0x7f)).chr
+          length >>= 7
+        end
+        @stdin.write proto
+      end
+    end
+  end
+
+  class MessageObserver
+    def initialize(obs, id, &block)
+      @obs = obs
+      @id = id
+      @block = block
+      @obs.add_observer self
+    end
+
+    def update(error, message)
+      if error
+        @obs.delete_observer self
+        @block.call error, nil
+      elsif message.error&.id == Sass::Transport::PROTOCOL_ERROR_ID
+        @obs.delete_observer self
+        @block.call Sass::ProtocolError.new(message.error.message), nil
+      else
+        res = message[message.message.to_s]
+        if (res['compilation_id'] || res['id']) == @id
+          @obs.delete_observer self
+          @block.call error, res
+        end
+      end
+    end
+  end
+end

data/lib/sass/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Sass
-  VERSION = '0.1.3'
+  VERSION = '0.2.1'
 end

data/test/compiler_test.rb

@@ -3,19 +3,19 @@
 require_relative 'test_helper'
 
 module Sass
-  class CompilerTest < MiniTest::Test
+  class EmbeddedTest < MiniTest::Test
     include TempFileTest
 
     def setup
-      @compiler = Embedded::Compiler.new
+      @embedded = Embedded.new
     end
 
     def teardown
-      @compiler.close
+      @embedded.close
     end
 
     def render(data)
-      @compiler.render({ data: data })[:css]
+      @embedded.render({ data: data })[:css]
     end
 
     def test_line_comments
@@ -31,7 +31,7 @@ module Sass
           baz: bang;
         }
       CSS
-      output = @compiler.render({
+      output = @embedded.render({
                                   data: template,
                                   source_comments: true
                                 })
@@ -97,7 +97,7 @@ module Sass
           baz: 0.33333333;
         }
       CSS
-      output = @compiler.render({
+      output = @embedded.render({
                                   data: template,
                                   precision: 8
                                 })
@@ -134,7 +134,7 @@ module Sass
                   padding: 20px;
                 }
       SCSS
-      output = @compiler.render({
+      output = @embedded.render({
                                   data: File.read('style.scss'),
                                   source_map: 'style.scss.map'
                                 })
@@ -143,7 +143,7 @@ module Sass
     end
 
     def test_no_source_map
-      output = @compiler.render({
+      output = @embedded.render({
                                   data: '$size: 30px;'
                                 })
       assert_equal '', output[:map]
@@ -157,7 +157,7 @@ module Sass
       temp_file('included_2/import.scss', "@use 'import_parent' as *; $size: $s;")
       temp_file('styles.scss', "@use 'import.scss' as *; .hi { width: $size; }")
 
-      assert_equal ".hi {\n  width: 30px;\n}", @compiler.render({
+      assert_equal ".hi {\n  width: 30px;\n}", @embedded.render({
                                                                   data: File.read('styles.scss'),
                                                                   include_paths: %w[
                                                                     included_1 included_2
@@ -216,9 +216,9 @@ module Sass
         }
       CSS
 
-      assert_equal css, @compiler.render({ data: sass, indented_syntax: true })[:css]
+      assert_equal css, @embedded.render({ data: sass, indented_syntax: true })[:css]
       assert_raises(CompilationError) do
-        @compiler.render({ data: sass, indented_syntax: false })
+        @embedded.render({ data: sass, indented_syntax: false })
       end
     end
 
@@ -230,7 +230,7 @@ module Sass
           baz: bang; }
       SCSS
 
-      output = @compiler.render({
+      output = @embedded.render({
                                   data: template,
                                   source_map: '.',
                                   source_map_embed: true,
@@ -263,7 +263,7 @@ module Sass
         threads = []
         10.times do |i|
           threads << Thread.new(i) do |id|
-            output = @compiler.render({
+            output = @embedded.render({
                                         data: "div { width: #{id} }"
                                       })[:css]
             assert_match(/#{id}/, output)

data/test/custom_importer_test.rb

@@ -7,15 +7,15 @@ module Sass
     include TempFileTest
 
     def setup
-      @compiler = Embedded::Compiler.new
+      @embedded = Embedded.new
     end
 
     def teardown
-      @compiler.close
+      @embedded.close
     end
 
     def render(data, importer)
-      @compiler.render({ data: data, importer: importer })[:css]
+      @embedded.render({ data: data, importer: importer })[:css]
     end
 
     def test_custom_importer_works
@@ -116,7 +116,7 @@ module Sass
     end
 
     def test_parent_path_is_accessible
-      output = @compiler.render({
+      output = @embedded.render({
                                   data: "@import 'parent.scss';",
                                   file: 'import-parent-filename.scss',
                                   importer: [
@@ -133,13 +133,13 @@ module Sass
       CSS
     end
 
-    def test_call_compiler_importer
-      output = @compiler.render({
+    def test_call_embedded_importer
+      output = @embedded.render({
                                   data: "@import 'parent.scss';",
                                   importer: [
                                     lambda { |_url, _prev|
                                       {
-                                        contents: @compiler.render({
+                                        contents: @embedded.render({
                                                                      data: "@import 'parent-parent.scss'",
                                                                      importer: [
                                                                        lambda { |_url, _prev|

data/test/error_test.rb

@@ -5,11 +5,11 @@ require_relative 'test_helper'
 module Sass
   class ErrorTest < MiniTest::Test
     def setup
-      @compiler = Embedded::Compiler.new
+      @embedded = Embedded.new
     end
 
     def teardown
-      @compiler.close
+      @embedded.close
     end
 
     def test_first_backtrace_is_sass
@@ -20,7 +20,7 @@ module Sass
         }
       SCSS
 
-      @compiler.render({
+      @embedded.render({
                          data: template
                        })
     rescue Sass::CompilationError => e

data/test/functions_test.rb

@@ -5,15 +5,15 @@ require_relative 'test_helper'
 module Sass
   class FunctionsTest < MiniTest::Test
     def setup
-      @compiler = Embedded::Compiler.new
+      @embedded = Embedded.new
     end
 
     def teardown
-      @compiler.close
+      @embedded.close
     end
 
     def render(sass)
-      @compiler.render({
+      @embedded.render({
                          data: sass,
                          functions: {
                            'javascript_path($path)': lambda { |path|
@@ -322,7 +322,7 @@ module Sass
         threads = []
         10.times do |i|
           threads << Thread.new(i) do |id|
-            output = @compiler.render({
+            output = @embedded.render({
                                         data: 'div { url: test-function() }',
                                         functions: {
                                           'test_function()': lambda {
@@ -346,7 +346,7 @@ module Sass
     end
 
     def test_pass_custom_functions_as_a_parameter
-      output = @compiler.render({
+      output = @embedded.render({
                                   data: 'div { url: test-function(); }',
                                   functions: {
                                     'test_function()': lambda {
@@ -365,7 +365,7 @@ module Sass
 
     def test_pass_incompatible_type_to_custom_functions
       assert_raises(CompilationError) do
-        @compiler.render({
+        @embedded.render({
                            data: 'div { url: test-function(); }',
                            functions: {
                              'test_function()': lambda {

data/test/output_style_test.rb

@@ -5,11 +5,11 @@ require_relative 'test_helper'
 module Sass
   class OutputStyleTest < MiniTest::Test
     def setup
-      @compiler = Embedded::Compiler.new
+      @embedded = Embedded.new
     end
 
     def teardown
-      @compiler.close
+      @embedded.close
     end
 
     def input_scss
@@ -51,40 +51,40 @@ module Sass
     end
 
     def test_expanded_output_is_default
-      output = @compiler.render({ data: input_scss })[:css]
+      output = @embedded.render({ data: input_scss })[:css]
       assert_equal expected_expanded_output, output
     end
 
     def test_output_style_accepts_strings
-      output = @compiler.render({ data: input_scss, output_style: :expanded })[:css]
+      output = @embedded.render({ data: input_scss, output_style: :expanded })[:css]
       assert_equal expected_expanded_output, output
     end
 
     def test_invalid_output_style
       assert_raises(InvalidStyleError) do
-        @compiler.render({ data: input_scss, output_style: :totally_wrong })[:css]
+        @embedded.render({ data: input_scss, output_style: :totally_wrong })[:css]
       end
     end
 
     def test_unsupported_output_style
       assert_raises(UnsupportedValue) do
-        @compiler.render({ data: input_scss, output_style: :nested })[:css]
+        @embedded.render({ data: input_scss, output_style: :nested })[:css]
       end
 
       assert_raises(UnsupportedValue) do
-        @compiler.render({ data: input_scss, output_style: :compact })[:css]
+        @embedded.render({ data: input_scss, output_style: :compact })[:css]
       end
     end
 
     def test_compressed_output
-      output = @compiler.render({ data: input_scss, output_style: :compressed })[:css]
+      output = @embedded.render({ data: input_scss, output_style: :compressed })[:css]
       assert_equal <<~CSS.chomp, output
         #main{color:#fff;background-color:#000}#main p{width:10em}.huge{font-size:10em;font-weight:bold;text-decoration:underline}
       CSS
     end
 
     def test_string_output_style_names
-      output = @compiler.render({ data: input_scss, output_style: 'compressed' })[:css]
+      output = @embedded.render({ data: input_scss, output_style: 'compressed' })[:css]
       assert_equal <<~CSS.chomp, output
         #main{color:#fff;background-color:#000}#main p{width:10em}.huge{font-size:10em;font-weight:bold;text-decoration:underline}
       CSS

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: sass-embedded
 version: !ruby/object:Gem::Version
-  version: 0.1.3
+  version: 0.2.1
 platform: ruby
 authors:
 - なつき
@@ -126,10 +126,10 @@ files:
 - ext/sass_embedded/Makefile
 - ext/sass_embedded/extconf.rb
 - lib/sass.rb
-- lib/sass/embedded/compiler.rb
-- lib/sass/embedded/transport.rb
+- lib/sass/embedded.rb
 - lib/sass/error.rb
 - lib/sass/platform.rb
+- lib/sass/transport.rb
 - lib/sass/util.rb
 - lib/sass/version.rb
 - sass-embedded.gemspec

data/lib/sass/embedded/compiler.rb

@@ -1,238 +0,0 @@
-# frozen_string_literal: true
-
-module Sass
-  module Embedded
-    class Compiler
-      def initialize
-        @transport = Transport.new
-        @id_semaphore = Mutex.new
-        @id = 0
-      end
-
-      def render(options)
-        start = Sass::Util.now
-
-        raise Sass::NotRenderedError, 'Either :data or :file must be set.' if options[:file].nil? && options[:data].nil?
-
-        string = if options[:data]
-                   Sass::EmbeddedProtocol::InboundMessage::CompileRequest::StringInput.new(
-                     source: options[:data],
-                     url: options[:file] ? Sass::Util.file_uri(options[:file]) : 'stdin',
-                     syntax: options[:indented_syntax] == true ? Sass::EmbeddedProtocol::Syntax::INDENTED : Sass::EmbeddedProtocol::Syntax::SCSS
-                   )
-                 end
-
-        path = options[:data] ? nil : options[:file]
-
-        style = case options[:output_style]&.to_sym
-                when :expanded, nil
-                  Sass::EmbeddedProtocol::OutputStyle::EXPANDED
-                when :compressed
-                  Sass::EmbeddedProtocol::OutputStyle::COMPRESSED
-                when :nested, :compact
-                  raise Sass::UnsupportedValue, "#{options[:output_style]} is not a supported :output_style"
-                else
-                  raise Sass::InvalidStyleError, "#{options[:output_style]} is not a valid :output_style"
-                end
-
-        source_map = options[:source_map].is_a?(String) || (options[:source_map] == true && !options[:out_file].nil?)
-
-        # 1. Loading a file relative to the file in which the @use or @import appeared.
-        # 2. Each custom importer.
-        # 3. Loading a file relative to the current working directory.
-        # 4. Each load path in includePaths
-        # 5. Each load path specified in the SASS_PATH environment variable, which should be semicolon-separated on Windows and colon-separated elsewhere.
-        importers = (if options[:importer]
-                       [
-                         Sass::EmbeddedProtocol::InboundMessage::CompileRequest::Importer.new(importer_id: 0)
-                       ]
-                     else
-                       []
-                     end).concat(
-                       (options[:include_paths] || []).concat(Sass.include_paths)
-                       .map do |include_path|
-                         Sass::EmbeddedProtocol::InboundMessage::CompileRequest::Importer.new(
-                           path: File.absolute_path(include_path)
-                         )
-                       end
-                     )
-
-        signatures = []
-        functions = {}
-        options[:functions]&.each do |signature, function|
-          signatures.push signature
-          functions[signature.to_s.split('(')[0].chomp] = function
-        end
-
-        compilation_id = next_id
-
-        compile_request = Sass::EmbeddedProtocol::InboundMessage::CompileRequest.new(
-          id: compilation_id,
-          string: string,
-          path: path,
-          style: style,
-          source_map: source_map,
-          importers: importers,
-          global_functions: options[:functions] ? signatures : [],
-          alert_color: true,
-          alert_ascii: true
-        )
-
-        response = @transport.send compile_request, compilation_id
-
-        file = options[:file] || 'stdin'
-        canonicalizations = {}
-        imports = {}
-
-        loop do
-          case response
-          when Sass::EmbeddedProtocol::OutboundMessage::CompileResponse
-            break
-          when Sass::EmbeddedProtocol::OutboundMessage::CanonicalizeRequest
-            url = Sass::Util.file_uri(File.absolute_path(response.url, File.dirname(file)))
-
-            if canonicalizations.key? url
-              canonicalizations[url].id = response.id
-            else
-              resolved = nil
-              options[:importer].each do |importer|
-                begin
-                  resolved = importer.call response.url, file
-                rescue StandardError => e
-                  resolved = e
-                end
-                break if resolved
-              end
-              if resolved.nil?
-                canonicalizations[url] = Sass::EmbeddedProtocol::InboundMessage::CanonicalizeResponse.new(
-                  id: response.id,
-                  url: url
-                )
-              elsif resolved.is_a? StandardError
-                canonicalizations[url] = Sass::EmbeddedProtocol::InboundMessage::CanonicalizeResponse.new(
-                  id: response.id,
-                  error: resolved.message
-                )
-              elsif resolved.key? :contents
-                canonicalizations[url] = Sass::EmbeddedProtocol::InboundMessage::CanonicalizeResponse.new(
-                  id: response.id,
-                  url: url
-                )
-                imports[url] = Sass::EmbeddedProtocol::InboundMessage::ImportResponse.new(
-                  id: response.id,
-                  success: Sass::EmbeddedProtocol::InboundMessage::ImportResponse::ImportSuccess.new(
-                    contents: resolved[:contents],
-                    syntax: Sass::EmbeddedProtocol::Syntax::SCSS,
-                    source_map_url: nil
-                  )
-                )
-              elsif resolved.key? :file
-                canonicalized_url = Sass::Util.file_uri(resolved[:file])
-                canonicalizations[url] = Sass::EmbeddedProtocol::InboundMessage::CanonicalizeResponse.new(
-                  id: response.id,
-                  url: canonicalized_url
-                )
-                imports[canonicalized_url] = Sass::EmbeddedProtocol::InboundMessage::ImportResponse.new(
-                  id: response.id,
-                  success: Sass::EmbeddedProtocol::InboundMessage::ImportResponse::ImportSuccess.new(
-                    contents: File.read(resolved[:file]),
-                    syntax: Sass::EmbeddedProtocol::Syntax::SCSS,
-                    source_map_url: nil
-                  )
-                )
-              else
-                canonicalizations[url] = Sass::EmbeddedProtocol::InboundMessage::CanonicalizeResponse.new(
-                  id: response.id,
-                  error: "Unexpected value returned from importer: #{resolved}"
-                )
-              end
-            end
-
-            response = @transport.send canonicalizations[url], compilation_id
-          when Sass::EmbeddedProtocol::OutboundMessage::ImportRequest
-            url = response.url
-
-            if imports.key? url
-              imports[url].id = response.id
-            else
-              imports[url] = Sass::EmbeddedProtocol::InboundMessage::ImportResponse.new(
-                id: response.id,
-                error: "Failed to import: #{url}"
-              )
-            end
-
-            response = @transport.send imports[url], compilation_id
-          when Sass::EmbeddedProtocol::OutboundMessage::FunctionCallRequest
-            begin
-              message = Sass::EmbeddedProtocol::InboundMessage::FunctionCallResponse.new(
-                id: response.id,
-                success: functions[response.name].call(*response.arguments)
-              )
-            rescue StandardError => e
-              message = Sass::EmbeddedProtocol::InboundMessage::FunctionCallResponse.new(
-                id: response.id,
-                error: e.message
-              )
-            end
-
-            response = @transport.send message, compilation_id
-          when Sass::EmbeddedProtocol::ProtocolError
-            raise Sass::ProtocolError, response.message
-          else
-            raise Sass::ProtocolError, "Unexpected packet received: #{response}"
-          end
-        end
-
-        if response.failure
-          raise Sass::CompilationError.new(
-            response.failure.message,
-            response.failure.formatted,
-            response.failure.span ? response.failure.span.url : nil,
-            response.failure.span ? response.failure.span.start.line + 1 : nil,
-            response.failure.span ? response.failure.span.start.column + 1 : nil,
-            1
-          )
-        end
-
-        finish = Sass::Util.now
-
-        {
-          css: response.success.css,
-          map: response.success.source_map,
-          stats: {
-            entry: options[:file] || 'data',
-            start: start,
-            end: finish,
-            duration: finish - start
-          }
-        }
-      end
-
-      def close
-        @transport.close
-      end
-
-      private
-
-      def info
-        version_response = @transport.send Sass::EmbeddedProtocol::InboundMessage::VersionRequest.new(
-          id: next_id
-        )
-        {
-          compiler_version: version_response.compiler_version,
-          protocol_version: version_response.protocol_version,
-          implementation_name: version_response.implementation_name,
-          implementation_version: version_response.implementation_version
-        }
-      end
-
-      def next_id
-        @id_semaphore.synchronize do
-          @id += 1
-          @id = 0 if @id == Transport::PROTOCOL_ERROR_ID
-          @id
-        end
-      end
-    end
-  end
-end

data/lib/sass/embedded/transport.rb

@@ -1,140 +0,0 @@
-# frozen_string_literal: true
-
-require 'open3'
-require 'observer'
-require_relative '../../../ext/sass_embedded/embedded_sass_pb'
-
-module Sass
-  module Embedded
-    class Transport
-      include Observable
-
-      DART_SASS_EMBEDDED = File.absolute_path(
-        "../../../ext/sass_embedded/sass_embedded/dart-sass-embedded#{Sass::Platform::OS == 'windows' ? '.bat' : ''}", __dir__
-      )
-
-      PROTOCOL_ERROR_ID = 4_294_967_295
-
-      def initialize
-        @stdin, @stdout, @stderr, @wait_thread = Open3.popen3(DART_SASS_EMBEDDED)
-        @stdin_semaphore = Mutex.new
-        @observerable_semaphore = Mutex.new
-
-        Thread.new do
-          loop do
-            bits = length = 0
-            loop do
-              byte = @stdout.readbyte
-              length += (byte & 0x7f) << bits
-              bits += 7
-              break if byte <= 0x7f
-            end
-            changed
-            payload = @stdout.read length
-            @observerable_semaphore.synchronize do
-              notify_observers nil, Sass::EmbeddedProtocol::OutboundMessage.decode(payload)
-            end
-          rescue Interrupt
-            break
-          rescue IOError => e
-            notify_observers e, nil
-            close
-            break
-          end
-        end
-
-        Thread.new do
-          loop do
-            warn @stderr.read
-          rescue Interrupt
-            break
-          rescue IOError => e
-            @observerable_semaphore.synchronize do
-              notify_observers e, nil
-            end
-            close
-            break
-          end
-        end
-      end
-
-      def send(req, id)
-        mutex = Mutex.new
-        resource = ConditionVariable.new
-
-        req_name = req.class.name.split('::').last.gsub(/\B(?=[A-Z])/, '_').downcase
-
-        message = Sass::EmbeddedProtocol::InboundMessage.new(req_name.to_sym => req)
-
-        error = nil
-        res = nil
-
-        @observerable_semaphore.synchronize do
-          MessageObserver.new self, id do |e, r|
-            mutex.synchronize do
-              error = e
-              res = r
-
-              resource.signal
-            end
-          end
-        end
-
-        mutex.synchronize do
-          write message.to_proto
-
-          resource.wait(mutex)
-        end
-
-        raise error if error
-
-        res
-      end
-
-      def close
-        delete_observers
-        @stdin.close unless @stdin.closed?
-        @stdout.close unless @stdout.closed?
-        @stderr.close unless @stderr.closed?
-      end
-
-      private
-
-      def write(proto)
-        @stdin_semaphore.synchronize do
-          length = proto.length
-          while length.positive?
-            @stdin.write ((length > 0x7f ? 0x80 : 0) | (length & 0x7f)).chr
-            length >>= 7
-          end
-          @stdin.write proto
-        end
-      end
-    end
-
-    class MessageObserver
-      def initialize(obs, id, &block)
-        @obs = obs
-        @id = id
-        @block = block
-        @obs.add_observer self
-      end
-
-      def update(error, message)
-        if error
-          @obs.delete_observer self
-          @block.call error, nil
-        elsif message.error&.id == Sass::Embedded::Transport::PROTOCOL_ERROR_ID
-          @obs.delete_observer self
-          @block.call Sass::ProtocolError.new(message.error.message), nil
-        else
-          res = message[message.message.to_s]
-          if (res['compilation_id'] ? res['compilation_id'] : res['id']) == @id
-            @obs.delete_observer self
-            @block.call error, res
-          end
-        end
-      end
-    end
-  end
-end