sass-embedded 0.1.1 → 0.2.3

data/lib/sass/error.rb

@@ -1,15 +1,17 @@
 # frozen_string_literal: true
 
 module Sass
-
   class BaseError < StandardError; end
+
   class ProtocolError < BaseError; end
+
   class NotRenderedError < BaseError; end
+
   class InvalidStyleError < BaseError; end
+
   class UnsupportedValue < BaseError; end
 
   class CompilationError < BaseError
-
     attr_accessor :formatted, :file, :line, :column, :status
 
     def initialize(message, formatted, file, line, column, status)
@@ -23,6 +25,7 @@ module Sass
 
     def backtrace
       return nil if super.nil?
+
       ["#{@file}:#{@line}:#{@column}"] + super
     end
   end

data/lib/sass/platform.rb

@@ -1,27 +1,24 @@
 # frozen_string_literal: true
 
-
-
 module Sass
   module Platform
-
     OS = case RbConfig::CONFIG['host_os'].downcase
          when /linux/
-           "linux"
+           'linux'
          when /darwin/
-           "darwin"
+           'darwin'
          when /freebsd/
-           "freebsd"
+           'freebsd'
          when /netbsd/
-           "netbsd"
+           'netbsd'
          when /openbsd/
-           "openbsd"
+           'openbsd'
          when /dragonfly/
-           "dragonflybsd"
+           'dragonflybsd'
          when /sunos|solaris/
-           "solaris"
+           'solaris'
          when /mingw|mswin/
-           "windows"
+           'windows'
          else
            RbConfig::CONFIG['host_os'].downcase
          end
@@ -32,22 +29,22 @@ module Sass
 
     ARCH = case CPU.downcase
            when /amd64|x86_64|x64/
-             "x86_64"
+             'x86_64'
            when /i\d86|x86|i86pc/
-             "i386"
+             'i386'
            when /ppc64|powerpc64/
-             "powerpc64"
+             'powerpc64'
            when /ppc|powerpc/
-             "powerpc"
+             'powerpc'
            when /sparcv9|sparc64/
-             "sparcv9"
+             'sparcv9'
            when /arm64|aarch64/  # MacOS calls it "arm64", other operating systems "aarch64"
-             "aarch64"
+             'aarch64'
            when /^arm/
-             if OS == "darwin"   # Ruby before 3.0 reports "arm" instead of "arm64" as host_cpu on darwin
-               "aarch64"
+             if OS == 'darwin'   # Ruby before 3.0 reports "arm" instead of "arm64" as host_cpu on darwin
+               'aarch64'
              else
-               "arm"
+               'arm'
              end
            else
              RbConfig::CONFIG['host_cpu']

data/lib/sass/transport.rb

@@ -0,0 +1,139 @@
+# 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?
+      nil
+    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
+
+    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
+end

data/lib/sass/util.rb

@@ -2,18 +2,18 @@
 
 module Sass
   module Util
-    extend self
+    module_function
 
-    def file_uri path
+    def file_uri(path)
       absolute_path = File.absolute_path(path)
 
-      if !absolute_path.start_with?('/')
+      unless absolute_path.start_with?('/')
         components = absolute_path.split File::SEPARATOR
         components[0] = components[0].split(':').first.downcase
         absolute_path = components.join File::SEPARATOR
       end
 
-      'file://' + absolute_path
+      "file://#{absolute_path}"
     end
 
     def now

data/lib/sass/version.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
 module Sass
-  VERSION = "0.1.1"
+  VERSION = '0.2.3'
 end
-

data/sass-embedded.gemspec

@@ -1,37 +1,36 @@
 # frozen_string_literal: true
 
-lib = File.expand_path("../lib", __FILE__)
+lib = File.expand_path('lib', __dir__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-require "sass/version"
+require 'sass/version'
 
 Gem::Specification.new do |spec|
-
-  spec.name          = "sass-embedded"
+  spec.name          = 'sass-embedded'
   spec.version       = Sass::VERSION
-  spec.authors       = ["なつき"]
-  spec.email         = ["i@ntk.me"]
-  spec.summary       = "Use dart-sass with Ruby!"
-  spec.description   = "Use dart-sass with Ruby!"
-  spec.homepage      = "https://github.com/ntkme/embedded-host-ruby"
-  spec.license       = "MIT"
+  spec.authors       = ['なつき']
+  spec.email         = ['i@ntk.me']
+  spec.summary       = 'Use dart-sass with Ruby!'
+  spec.description   = 'Use dart-sass with Ruby!'
+  spec.homepage      = 'https://github.com/ntkme/embedded-host-ruby'
+  spec.license       = 'MIT'
 
   spec.files         = `git ls-files -z`.split("\x0")
   spec.extensions    = ['ext/sass_embedded/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.0.0"
-
-  spec.require_paths = ["lib"]
+  spec.require_paths = ['lib']
 
   spec.platform      = Gem::Platform::RUBY
 
-  spec.add_dependency "google-protobuf", "~> 3.17.0"
+  spec.add_dependency 'google-protobuf', '~> 3.17.0'
 
-  spec.add_development_dependency "bundler"
-  spec.add_development_dependency "minitest", "~> 5.14.4"
-  spec.add_development_dependency "minitest-around"
-  spec.add_development_dependency "rake"
-  spec.add_development_dependency "rake-compiler"
+  spec.add_development_dependency 'bundler'
+  spec.add_development_dependency 'minitest', '~> 5.14.4'
+  spec.add_development_dependency 'minitest-around'
+  spec.add_development_dependency 'rake'
+  spec.add_development_dependency 'rake-compiler'
+  spec.add_development_dependency 'rubocop'
 end

data/test/compiler_test.rb

@@ -1,119 +1,120 @@
 # frozen_string_literal: true
 
-require_relative "test_helper"
+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
+      @embedded.close
     end
 
     def render(data)
-      @compiler.render({ data: data })[:css]
+      @embedded.render({ data: data })[:css]
     end
 
     def test_line_comments
       skip 'not supported'
 
-      template = <<-SCSS
-.foo {
-  baz: bang; }
+      template = <<~SCSS
+        .foo {
+          baz: bang; }
       SCSS
-      expected_output = <<-CSS
-/* line 1, stdin */
-.foo {
-  baz: bang;
-}
+      expected_output = <<~CSS
+        /* line 1, stdin */
+        .foo {
+          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
 
     def test_one_line_comments
-      assert_equal <<CSS.chomp, render(<<SCSS)
-.foo {
-  baz: bang;
-}
-CSS
-.foo {// bar: baz;}
-  baz: bang; //}
-}
-SCSS
-      assert_equal <<CSS.chomp, render(<<SCSS)
-.foo bar[val="//"] {
-  baz: bang;
-}
-CSS
-.foo bar[val="//"] {
-  baz: bang; //}
-}
-SCSS
-  end
+      assert_equal <<~CSS.chomp, render(<<~SCSS)
+        .foo {
+          baz: bang;
+        }
+      CSS
+        .foo {// bar: baz;}
+          baz: bang; //}
+        }
+      SCSS
+      assert_equal <<~CSS.chomp, render(<<~SCSS)
+        .foo bar[val="//"] {
+          baz: bang;
+        }
+      CSS
+        .foo bar[val="//"] {
+          baz: bang; //}
+        }
+      SCSS
+    end
 
     def test_variables
-      assert_equal <<CSS.chomp, render(<<SCSS)
-blat {
-  a: foo;
-}
-CSS
-$var: foo;
-
-blat {a: $var}
-SCSS
-
-      assert_equal <<CSS.chomp, render(<<SCSS)
-foo {
-  a: 2;
-  b: 6;
-}
-CSS
-foo {
-  $var: 2;
-  $another-var: 4;
-  a: $var;
-  b: $var + $another-var;}
-SCSS
+      assert_equal <<~CSS.chomp, render(<<~SCSS)
+        blat {
+          a: foo;
+        }
+      CSS
+                $var: foo;
+        #{'        '}
+                blat {a: $var}
+      SCSS
+
+      assert_equal <<~CSS.chomp, render(<<~SCSS)
+        foo {
+          a: 2;
+          b: 6;
+        }
+      CSS
+        foo {
+          $var: 2;
+          $another-var: 4;
+          a: $var;
+          b: $var + $another-var;}
+      SCSS
     end
 
     def test_precision
       skip 'not supported'
 
-      template = <<-SCSS
-$var: 1;
-.foo {
-  baz: $var / 3; }
-SCSS
-      expected_output = <<-CSS.chomp
-.foo {
-  baz: 0.33333333;
-}
-CSS
-      output = @compiler.render({
-        data: template,
-        precision: 8
-      })
+      template = <<~SCSS
+        $var: 1;
+        .foo {
+          baz: $var / 3; }
+      SCSS
+      expected_output = <<~CSS.chomp
+        .foo {
+          baz: 0.33333333;
+        }
+      CSS
+      output = @embedded.render({
+                                  data: template,
+                                  precision: 8
+                                })
       assert_equal expected_output, output
     end
 
     def test_precision_not_specified
-      template = <<-SCSS
-$var: 1;
-.foo {
-  baz: $var / 3; }
-SCSS
-      expected_output = <<-CSS.chomp
-.foo {
-  baz: 0.3333333333;
-}
-CSS
+      template = <<~SCSS
+        $var: 1;
+        .foo {
+          baz: $var / 3; }
+      SCSS
+      expected_output = <<~CSS.chomp
+        .foo {
+          baz: 0.3333333333;
+        }
+      CSS
       output = render(template)
       assert_equal expected_output, output
     end
@@ -121,126 +122,123 @@ CSS
     def test_source_map
       temp_dir('admin')
 
-      temp_file('admin/text-color.scss', <<SCSS)
-p {
-  color: red;
-}
-SCSS
-      temp_file('style.scss', <<SCSS)
-@use 'admin/text-color';
-
-p {
-  padding: 20px;
-}
-SCSS
-      output = @compiler.render({
-        data: File.read("style.scss"),
-        source_map: "style.scss.map"
-      })
+      temp_file('admin/text-color.scss', <<~SCSS)
+        p {
+          color: red;
+        }
+      SCSS
+      temp_file('style.scss', <<~SCSS)
+                @use 'admin/text-color';
+        #{'        '}
+                p {
+                  padding: 20px;
+                }
+      SCSS
+      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;"
-      })
-      assert_equal "", output[:map]
+      output = @embedded.render({
+                                  data: '$size: 30px;'
+                                })
+      assert_equal '', output[:map]
     end
 
     def test_include_paths
-      temp_dir("included_1")
-      temp_dir("included_2")
-
-      temp_file("included_1/import_parent.scss", "$s: 30px;")
-      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: [ "included_1", "included_2" ]
-      })[:css]
+      temp_dir('included_1')
+      temp_dir('included_2')
+
+      temp_file('included_1/import_parent.scss', '$s: 30px;')
+      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}", @embedded.render({
+                                                                  data: File.read('styles.scss'),
+                                                                  include_paths: %w[
+                                                                    included_1 included_2
+                                                                  ]
+                                                                })[:css]
     end
 
     def test_global_include_paths
-      skip 'race condition in test'
-
-      temp_dir("included_1")
-      temp_dir("included_2")
+      temp_dir('included_1')
+      temp_dir('included_2')
 
-      temp_file("included_1/import_parent.scss", "$s: 30px;")
-      temp_file("included_2/import.scss", "@use 'import_parent'; $size: $s;")
-      temp_file("styles.scss", "@use 'import.scss'; .hi { width: $size; }")
+      temp_file('included_1/import_parent.scss', '$s: 30px;')
+      temp_file('included_2/import.scss', "@use 'import_parent' as *; $size: $s;")
+      temp_file('styles.scss', "@use 'import.scss' as *; .hi { width: $size; }")
 
-      ::Sass.include_paths << "included_1"
-      ::Sass.include_paths << "included_2"
+      ::Sass.include_paths << 'included_1'
+      ::Sass.include_paths << 'included_2'
 
-      assert_equal ".hi {\n  width: 30px;\n}", render(File.read("styles.scss"))
+      assert_equal ".hi {\n  width: 30px;\n}", render(File.read('styles.scss'))
     end
 
     def test_env_include_paths
-      skip 'race condition in test'
+      expected_include_paths = %w[included_3 included_4]
 
-      expected_include_paths = [ "included_3", "included_4" ]
       ::Sass.instance_eval { @include_paths = nil }
+
       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
 
     def test_include_paths_not_configured
-      temp_dir("included_5")
-      temp_dir("included_6")
-      temp_file("included_5/import_parent.scss", "$s: 30px;")
-      temp_file("included_6/import.scss", "@use 'import_parent'; $size: $s;")
-      temp_file("styles.scss", "@use 'import.scss'; .hi { width: $size; }")
+      temp_dir('included_5')
+      temp_dir('included_6')
+      temp_file('included_5/import_parent.scss', '$s: 30px;')
+      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
-        render(File.read("styles.scss"))
+        render(File.read('styles.scss'))
       end
     end
 
     def test_sass_variation
-      sass = <<SASS
-$size: 30px
-.foo
-  width: $size
-SASS
-
-      css = <<CSS.chomp
-.foo {
-  width: 30px;
-}
-CSS
-
-      assert_equal css, @compiler.render({ data: sass, indented_syntax: true })[:css]
+      sass = <<~SASS
+        $size: 30px
+        .foo
+          width: $size
+      SASS
+
+      css = <<~CSS.chomp
+        .foo {
+          width: 30px;
+        }
+      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
 
     def test_inline_source_maps
       skip 'not supported'
 
-      template = <<-SCSS
-.foo {
-  baz: bang; }
+      template = <<~SCSS
+        .foo {
+          baz: bang; }
       SCSS
-      expected_output = <<-CSS
-/* line 1, stdin */
-.foo {
-  baz: bang; }
-      CSS
 
-      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
+      assert_match(/sourceMappingURL/, output)
+      assert_match(/.foo/, output)
     end
 
     def test_empty_template
@@ -249,12 +247,12 @@ CSS
     end
 
     def test_import_plain_css
-      temp_file("test.css", ".something{color: red}")
-      expected_output = <<-CSS.chomp
-.something {
-  color: red;
-}
-CSS
+      temp_file('test.css', '.something{color: red}')
+      expected_output = <<~CSS.chomp
+        .something {
+          color: red;
+        }
+      CSS
 
       output = render("@use 'test';")
       assert_equal expected_output, output
@@ -265,10 +263,10 @@ CSS
         threads = []
         10.times do |i|
           threads << Thread.new(i) do |id|
-            output = @compiler.render({
-              data: "div { width: #{id} }",
-            })[:css]
-            assert_match /#{id}/, output
+            output = @embedded.render({
+                                        data: "div { width: #{id} }"
+                                      })[:css]
+            assert_match(/#{id}/, output)
           end
         end
         threads.each(&:join)