sass-embedded 0.1.3 → 0.3.0

data/lib/sass/error.rb

@@ -1,17 +1,12 @@
 # frozen_string_literal: true
 
 module Sass
-  class BaseError < StandardError; end
+  class SassError < StandardError; end
 
-  class ProtocolError < BaseError; end
+  class ProtocolError < SassError; end
 
-  class NotRenderedError < BaseError; end
-
-  class InvalidStyleError < BaseError; end
-
-  class UnsupportedValue < BaseError; end
-
-  class CompilationError < BaseError
+  # The error returned by {Sass.render}
+  class RenderError < SassError
     attr_accessor :formatted, :file, :line, :column, :status
 
     def initialize(message, formatted, file, line, column, status)

data/lib/sass/transport.rb

@@ -0,0 +1,150 @@
+# frozen_string_literal: true
+
+require 'open3'
+require 'observer'
+require_relative '../../ext/embedded_sass_pb'
+
+module Sass
+  # The interface for communicating with dart-sass-embedded.
+  # It handles message serialization and deserialization as well as
+  # tracking concurrent request and response
+  class Transport
+    include Observable
+
+    DART_SASS_EMBEDDED = File.absolute_path(
+      "../../ext/sass_embedded/dart-sass-embedded#{Platform::OS == 'windows' ? '.bat' : ''}", __dir__
+    )
+
+    PROTOCOL_ERROR_ID = 4_294_967_295
+
+    def initialize
+      @stdin_semaphore = Mutex.new
+      @observerable_semaphore = Mutex.new
+      @stdin, @stdout, @stderr, @wait_thread = Open3.popen3(DART_SASS_EMBEDDED)
+      pipe @stderr, $stderr
+      receive
+    end
+
+    def send(req, res_id)
+      mutex = Mutex.new
+      resource = ConditionVariable.new
+
+      req_kind = req.class.name.split('::').last.gsub(/\B(?=[A-Z])/, '_').downcase
+
+      message = EmbeddedProtocol::InboundMessage.new(req_kind => req)
+
+      error = nil
+      res = nil
+
+      @observerable_semaphore.synchronize do
+        MessageObserver.new self, res_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?
+      nil
+    end
+
+    private
+
+    def receive
+      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, EmbeddedProtocol::OutboundMessage.decode(payload)
+          end
+        rescue Interrupt
+          break
+        rescue IOError => e
+          notify_observers e, nil
+          close
+          break
+        end
+      end
+    end
+
+    def pipe(readable, writeable)
+      Thread.new do
+        loop do
+          writeable.write readable.read
+        rescue Interrupt
+          break
+        rescue IOError => e
+          @observerable_semaphore.synchronize do
+            notify_observers e, nil
+          end
+          close
+          break
+        end
+      end
+    end
+
+    def write(payload)
+      @stdin_semaphore.synchronize do
+        length = payload.length
+        while length.positive?
+          @stdin.write ((length > 0x7f ? 0x80 : 0) | (length & 0x7f)).chr
+          length >>= 7
+        end
+        @stdin.write payload
+      end
+    end
+
+    # The observer used to listen on messages from stdout, check if id
+    # matches the given request id, and yield back to the given block.
+    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 == Transport::PROTOCOL_ERROR_ID
+          @obs.delete_observer self
+          @block.call 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
+end

data/lib/sass/util.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 module Sass
+  # Utilities functions
   module Util
     module_function
 

data/lib/sass/version.rb

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

data/sass-embedded.gemspec

@@ -15,11 +15,11 @@ Gem::Specification.new do |spec|
   spec.license       = 'MIT'
 
   spec.files         = `git ls-files -z`.split("\x0")
-  spec.extensions    = ['ext/sass_embedded/extconf.rb']
+  spec.extensions    = ['ext/extconf.rb']
   spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
 
-  spec.required_ruby_version = '>= 2.0.0'
+  spec.required_ruby_version = '>= 2.6'
 
   spec.require_paths = ['lib']
 
@@ -33,4 +33,6 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency 'rake'
   spec.add_development_dependency 'rake-compiler'
   spec.add_development_dependency 'rubocop'
+  spec.add_development_dependency 'rubocop-minitest'
+  spec.add_development_dependency 'rubocop-rake'
 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,10 +31,8 @@ module Sass
           baz: bang;
         }
       CSS
-      output = @compiler.render({
-                                  data: template,
-                                  source_comments: true
-                                })
+      output = @embedded.render(data: template,
+                                source_comments: true)
       assert_equal expected_output, output[:css]
     end
 
@@ -97,10 +95,8 @@ module Sass
           baz: 0.33333333;
         }
       CSS
-      output = @compiler.render({
-                                  data: template,
-                                  precision: 8
-                                })
+      output = @embedded.render(data: template,
+                                precision: 8)
       assert_equal expected_output, output
     end
 
@@ -134,18 +130,14 @@ module Sass
                   padding: 20px;
                 }
       SCSS
-      output = @compiler.render({
-                                  data: File.read('style.scss'),
-                                  source_map: 'style.scss.map'
-                                })
+      output = @embedded.render(data: File.read('style.scss'),
+                                source_map: 'style.scss.map')
 
       assert output[:map].start_with? '{"version":3,'
     end
 
     def test_no_source_map
-      output = @compiler.render({
-                                  data: '$size: 30px;'
-                                })
+      output = @embedded.render(data: '$size: 30px;')
       assert_equal '', output[:map]
     end
 
@@ -157,12 +149,10 @@ 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({
-                                                                  data: File.read('styles.scss'),
-                                                                  include_paths: %w[
-                                                                    included_1 included_2
-                                                                  ]
-                                                                })[:css]
+      assert_equal ".hi {\n  width: 30px;\n}", @embedded.render(data: File.read('styles.scss'),
+                                                                include_paths: %w[
+                                                                  included_1 included_2
+                                                                ])[:css]
     end
 
     def test_global_include_paths
@@ -186,7 +176,7 @@ module Sass
 
       ENV['SASS_PATH'] = expected_include_paths.join(File::PATH_SEPARATOR)
 
-      assert_equal expected_include_paths, Sass.include_paths
+      assert_equal expected_include_paths, ::Sass.include_paths
 
       ::Sass.include_paths.clear
     end
@@ -198,7 +188,7 @@ module Sass
       temp_file('included_6/import.scss', "@use 'import_parent' as *; $size: $s;")
       temp_file('styles.scss', "@use 'import.scss' as *; .hi { width: $size; }")
 
-      assert_raises(CompilationError) do
+      assert_raises(RenderError) do
         render(File.read('styles.scss'))
       end
     end
@@ -216,9 +206,9 @@ module Sass
         }
       CSS
 
-      assert_equal css, @compiler.render({ data: sass, indented_syntax: true })[:css]
-      assert_raises(CompilationError) do
-        @compiler.render({ data: sass, indented_syntax: false })
+      assert_equal css, @embedded.render(data: sass, indented_syntax: true)[:css]
+      assert_raises(RenderError) do
+        @embedded.render(data: sass, indented_syntax: false)
       end
     end
 
@@ -230,12 +220,10 @@ module Sass
           baz: bang; }
       SCSS
 
-      output = @compiler.render({
-                                  data: template,
-                                  source_map: '.',
-                                  source_map_embed: true,
-                                  source_map_contents: true
-                                })[:css]
+      output = @embedded.render(data: template,
+                                source_map: '.',
+                                source_map_embed: true,
+                                source_map_contents: true)[:css]
 
       assert_match(/sourceMappingURL/, output)
       assert_match(/.foo/, output)
@@ -263,9 +251,7 @@ module Sass
         threads = []
         10.times do |i|
           threads << Thread.new(i) do |id|
-            output = @compiler.render({
-                                        data: "div { width: #{id} }"
-                                      })[:css]
+            output = @embedded.render(data: "div { width: #{id} }")[:css]
             assert_match(/#{id}/, output)
           end
         end

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
@@ -86,17 +86,16 @@ module Sass
     end
 
     def test_custom_importer_that_does_not_resolve
-      assert_raises(CompilationError) do
+      assert_raises(RenderError) do
         render("@import 'test.scss';", [
                  lambda { |_url, _prev|
-                   return nil
                  }
                ])
       end
     end
 
     def test_custom_importer_that_returns_error
-      assert_raises(CompilationError) do
+      assert_raises(RenderError) do
         render("@import 'test.scss';", [
                  lambda { |_url, _prev|
                    IOError.new 'test error'
@@ -106,7 +105,7 @@ module Sass
     end
 
     def test_custom_importer_that_raises_error
-      assert_raises(CompilationError) do
+      assert_raises(RenderError) do
         render("@import 'test.scss';", [
                  lambda { |_url, _prev|
                    raise IOError, 'test error'
@@ -116,15 +115,13 @@ module Sass
     end
 
     def test_parent_path_is_accessible
-      output = @compiler.render({
-                                  data: "@import 'parent.scss';",
-                                  file: 'import-parent-filename.scss',
-                                  importer: [
-                                    lambda { |_url, prev|
-                                      { contents: ".#{prev} { color: red; }" }
-                                    }
-                                  ]
-                                })[:css]
+      output = @embedded.render(data: "@import 'parent.scss';",
+                                file: 'import-parent-filename.scss',
+                                importer: [
+                                  lambda { |_url, prev|
+                                    { contents: ".#{prev} { color: red; }" }
+                                  }
+                                ])[:css]
 
       assert_equal <<~CSS.chomp, output
         .import-parent-filename.scss {
@@ -133,24 +130,20 @@ module Sass
       CSS
     end
 
-    def test_call_compiler_importer
-      output = @compiler.render({
-                                  data: "@import 'parent.scss';",
-                                  importer: [
-                                    lambda { |_url, _prev|
-                                      {
-                                        contents: @compiler.render({
-                                                                     data: "@import 'parent-parent.scss'",
-                                                                     importer: [
-                                                                       lambda { |_url, _prev|
-                                                                         { contents: 'h1 { color: black; }' }
-                                                                       }
-                                                                     ]
-                                                                   })[:css]
-                                      }
+    def test_call_embedded_importer
+      output = @embedded.render(data: "@import 'parent.scss';",
+                                importer: [
+                                  lambda { |_url, _prev|
+                                    {
+                                      contents: @embedded.render(data: "@import 'parent-parent.scss'",
+                                                                 importer: [
+                                                                   lambda { |_url, _prev|
+                                                                     { contents: 'h1 { color: black; }' }
+                                                                   }
+                                                                 ])[:css]
                                     }
-                                  ]
-                                })[:css]
+                                  }
+                                ])[:css]
 
       assert_equal <<~CSS.chomp, output
         h1 {