sass-embedded 0.4.0 → 0.6.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c9afb73da6288ecf0360685cc9ddb4c072eb8840da50acaa8a52b67f09998e6c
-  data.tar.gz: 1a20d885e2e9f55ffd861f9428499f4c3bdea64a4aea81e44f356af8be69eccc
+  metadata.gz: b23c7315185f78d02c9776c433a60a3ea62ce88b80a877ec17c66d4565416b5e
+  data.tar.gz: ce45e36c77e6aa2d04e211e5a50d265b1095c33d3a695793b68dc181b9fcf71f
 SHA512:
-  metadata.gz: 679cfc5b502de2fdc5b33c8117b7e1d68f94acd62c7afbe04ebb17f9bceacdc677e8b35197cf239f92fed4e3d523468d71798d899c360d8402be127bdb50ac48
-  data.tar.gz: e1d698b3980914299ee2ce570bd1f109a875859c147f8930366df8e2dabcae94f0e0795339f6614f3f7828e365c191ba24554e30869e4bd106f565f1cbbb9af2
+  metadata.gz: 699daac722babfcca657ae536c65f31c7882273cec287d33c98bec4dbbef9c1ce38242fefaad89592de563495687ed151428bb1c9e331e7e85d4ee0eb023f1b3
+  data.tar.gz: b2cd65ecccfd4f07f8f280a493fe7484e819cce8210ae12fffd5ee954529a3fa3562d9a8f9a21ee2783ab98e36307f6421aedcdeea63ca832abf31ea7cd8d7b9

data/.rubocop.yml

@@ -7,8 +7,5 @@ AllCops:
 
   NewCops: enable
 
-Layout/LineLength:
-  Enabled: false
-
 Metrics:
   Enabled: false

data/README.md

@@ -6,6 +6,12 @@ This is a Ruby library that implements the host side of the [Embedded Sass proto
 
 It exposes a Ruby API for Sass that's backed by a native [Dart Sass](https://sass-lang.com/dart-sass) executable.
 
+## Install
+
+``` sh
+gem install sass-embedded
+```
+
 ## Usage
 
 ``` ruby
@@ -14,6 +20,26 @@ require "sass"
 Sass.render(file: "style.scss")
 ```
 
+## Options
+
+`Sass.render()` support the following options:
+
+- [`data`](https://sass-lang.com/documentation/js-api#data)
+- [`file`](https://sass-lang.com/documentation/js-api#file)
+- [`indented_syntax`](https://sass-lang.com/documentation/js-api#indentedsyntax)
+- [`include_paths`](https://sass-lang.com/documentation/js-api#includepaths)
+- [`output_style`](https://sass-lang.com/documentation/js-api#outputstyle)
+- [`indent_type`](https://sass-lang.com/documentation/js-api#indenttype)
+- [`indent_width`](https://sass-lang.com/documentation/js-api#indentwidth)
+- [`linefeed`](https://sass-lang.com/documentation/js-api#linefeed)
+- [`source_map`](https://sass-lang.com/documentation/js-api#sourcemap)
+- [`out_file`](https://sass-lang.com/documentation/js-api#outfile)
+- [`omit_source_map_url`](https://sass-lang.com/documentation/js-api#omitsourcemapurl)
+- [`source_map_embed`](https://sass-lang.com/documentation/js-api#sourcemapembed)
+- [`source_map_root`](https://sass-lang.com/documentation/js-api#sourcemaproot)
+- [`functions`](https://sass-lang.com/documentation/js-api#functions)
+- [`importer`](https://sass-lang.com/documentation/js-api#importer)
+
 ---
 
 Disclaimer: this is not an official Google product.

data/ext/extconf.rb

@@ -8,12 +8,24 @@ require 'fileutils'
 require_relative '../lib/sass/platform'
 
 module Sass
-  # Install dependencies for sass-embedded during gem install
+  # The dependency downloader. This downloads all the dependencies during gem
+  # installation. The companion Makefile then unpacks all downloaded
+  # dependencies. By default it downloads the latest release of each
+  # dependency from GitHub releases.
+  #
+  # It is possible to specify an alternative source or version of each
+  # dependency. Local sources can be used for offline installation.
+  #
+  # @example
+  #   gem install sass-embedded -- \
+  #     --with-protoc=file:///path/to/protoc-*.zip \
+  #     --with-sass-embedded=file:///path/to/sass_embedded-*.(tar.gz|zip) \
+  #     --with-sass-embedded-protocol=file:///path/to/embedded_sass.proto
   class Extconf
     def initialize
+      get_with_config('protoc', true) { latest_protoc }
       get_with_config('sass-embedded', true) { latest_sass_embedded }
       get_with_config('sass-embedded-protocol', true) { latest_sass_embedded_protocol }
-      get_with_config('protoc', true) { latest_protoc }
     end
 
     private

data/lib/sass.rb

@@ -1,50 +1,72 @@
 # frozen_string_literal: true
 
-# The Sass module
+# The Sass module. This communicates with Embedded Dart Sass using
+# the Embedded Sass protocol.
 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}. 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.
-  # The variable should be a colon-separated list of path names
-  # (semicolon-separated on Windows).
-  #
-  # @example
-  #   Sass.include_paths << File.dirname(__FILE__) + '/sass'
-  # @return [Array<String, Pathname>]
-  def self.include_paths
-    @include_paths ||= if ENV['SASS_PATH']
-                         ENV['SASS_PATH'].split(File::PATH_SEPARATOR)
-                       else
-                         []
-                       end
-  end
+  class << self
+    # 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 included via `@import` or `@use`. This include path is used by every
+    # instance of {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.
+    # The variable should be a colon-separated list of path names
+    # (semicolon-separated on Windows).
+    #
+    # @example
+    #   Sass.include_paths << File.dirname(__FILE__) + '/sass'
+    # @return [Array]
+    def include_paths
+      @include_paths ||= if ENV['SASS_PATH']
+                           ENV['SASS_PATH'].split(File::PATH_SEPARATOR)
+                         else
+                           []
+                         end
+    end
+
+    # The global {.info} method. This instantiates a global {Embedded} instance
+    # and calls {Embedded#info}.
+    #
+    # @raise [ProtocolError]
+    def info
+      embedded.info
+    end
+
+    # The global {.render} method. This instantiates a global {Embedded} instance
+    # and calls {Embedded#render}.
+    #
+    # See {file:README.md#options} for supported options.
+    #
+    # @example
+    #   Sass.render(data: 'h1 { font-size: 40px; }')
+    # @example
+    #   Sass.render(file: 'style.css')
+    # @return [Result]
+    # @raise [ProtocolError]
+    # @raise [RenderError]
+    def render(**kwargs)
+      embedded.render(**kwargs)
+    end
+
+    private
+
+    def embedded
+      return @embedded if defined?(@embedded) && !@embedded.closed?
 
-  # The global render methods. This method automatically instantiates a
-  # global {Sass::Embedded} instance when invoked the first time and call
-  # `:render` method on the instance thereafter. The global {Sass::Embedded}
-  # is automatically closed via {Kernel.at_exit}.
-  # @example
-  #   Sass.render(options)
-  # @return [Hash]
-  def self.render(**kwargs)
-    unless defined? @embedded
       @embedded = Sass::Embedded.new
-      at_exit do
-        @embedded.close
-      end
     end
-    @embedded.render(**kwargs)
   end
 end
 
-require_relative 'sass/version'
-require_relative 'sass/error'
 require_relative 'sass/platform'
 require_relative 'sass/util'
+require_relative 'sass/struct'
+require_relative 'sass/result'
+require_relative 'sass/error'
 require_relative 'sass/transport'
+require_relative 'sass/observer'
+require_relative 'sass/version'
+require_relative 'sass/render'
 require_relative 'sass/embedded'

data/lib/sass/embedded.rb

@@ -1,10 +1,17 @@
 # frozen_string_literal: true
 
-require 'json'
 require 'base64'
+require 'json'
 
 module Sass
-  # The interface for using dart-sass-embedded
+  # The {Embedded} host for using dart-sass-embedded. Each instance creates
+  # its own {Transport}.
+  #
+  # @example
+  #   embedded = Sass::Embedded.new
+  #   result = embedded.render(data: 'h1 { font-size: 40px; }')
+  #   result = embedded.render(file: 'style.css')
+  #   embedded.close
   class Embedded
     def initialize
       @transport = Transport.new
@@ -12,22 +19,28 @@ module Sass
       @id = 0
     end
 
+    # The {Embedded#info} method.
+    #
+    # @raise [ProtocolError]
     def info
-      @transport.send EmbeddedProtocol::InboundMessage::VersionRequest.new(
-        id: next_id
-      )
+      @info ||= Version.new(@transport, next_id).fetch
     end
 
+    # The {Embedded#render} method.
+    #
+    # See {file:README.md#options} for supported options.
+    #
+    # @return [Result]
+    # @raise [ProtocolError]
+    # @raise [RenderError]
     def render(data: nil,
                file: nil,
                indented_syntax: false,
                include_paths: [],
                output_style: :expanded,
-               # precision: 5,
                indent_type: :space,
                indent_width: 2,
                linefeed: :lf,
-               # source_comments: false,
                source_map: false,
                out_file: nil,
                omit_source_map_url: false,
@@ -42,61 +55,41 @@ module Sass
       indent_width = parse_indent_width(indent_width)
       linefeed = parse_linefeed(linefeed)
 
-      compilation_id = next_id
-
-      renderer = Renderer.new(
-        data: data,
-        file: file,
-        indented_syntax: indented_syntax,
-        include_paths: include_paths,
-        output_style: output_style,
-        source_map: source_map,
-        out_file: out_file,
-        functions: functions,
-        importer: importer
-      )
-
-      response = @transport.send renderer.compile_request(compilation_id), compilation_id
-
-      loop do
-        case response
-        when EmbeddedProtocol::OutboundMessage::CompileResponse
-          break
-        when EmbeddedProtocol::OutboundMessage::CanonicalizeRequest
-          response = @transport.send renderer.canonicalize_response(response), compilation_id
-        when EmbeddedProtocol::OutboundMessage::ImportRequest
-          response = @transport.send renderer.import_response(response), compilation_id
-        when EmbeddedProtocol::OutboundMessage::FunctionCallRequest
-          response = @transport.send renderer.function_call_response(response), compilation_id
-        when EmbeddedProtocol::ProtocolError
-          raise ProtocolError, response.message
-        else
-          raise ProtocolError, "Unexpected packet received: #{response}"
-        end
-      end
-
-      if response.failure
+      message = Render.new(@transport, next_id,
+                           data: data,
+                           file: file,
+                           indented_syntax: indented_syntax,
+                           include_paths: include_paths,
+                           output_style: output_style,
+                           source_map: source_map,
+                           out_file: out_file,
+                           functions: functions,
+                           importer: importer).fetch
+
+      if message.failure
         raise RenderError.new(
-          response.failure.message,
-          response.failure.formatted,
-          if response.failure.span&.url == ''
+          message.failure.message,
+          message.failure.formatted,
+          if message.failure.span.nil?
+            nil
+          elsif message.failure.span.url == ''
             'stdin'
           else
-            Util.path(response.failure.span.url)
+            Util.path(message.failure.span.url)
           end,
-          response.failure.span ? response.failure.span.start.line + 1 : nil,
-          response.failure.span ? response.failure.span.start.column + 1 : nil,
+          message.failure.span ? message.failure.span.start.line + 1 : nil,
+          message.failure.span ? message.failure.span.start.column + 1 : nil,
           1
         )
       end
 
-      map, source_map = post_process_map(map: response.success.source_map,
+      map, source_map = post_process_map(map: message.success.source_map,
                                          file: file,
                                          out_file: out_file,
                                          source_map: source_map,
                                          source_map_root: source_map_root)
 
-      css = post_process_css(css: response.success.css,
+      css = post_process_css(css: message.success.css,
                              indent_type: indent_type,
                              indent_width: indent_width,
                              linefeed: linefeed,
@@ -108,21 +101,17 @@ module Sass
 
       finish = Util.now
 
-      {
-        css: css,
-        map: map,
-        stats: {
-          entry: file.nil? ? 'data' : file,
-          start: start,
-          end: finish,
-          duration: finish - start
-        }
-      }
+      stats = Result::Stats.new(file.nil? ? 'data' : file, start, finish, finish - start)
+
+      Result.new(css, map, stats)
     end
 
     def close
       @transport.close
-      nil
+    end
+
+    def closed?
+      @transport.closed?
     end
 
     private
@@ -205,7 +194,7 @@ module Sass
       when :tab
         "\t"
       else
-        raise ArgumentError, 'indent_type must be :space or :tab'
+        raise ArgumentError, 'indent_type must be one of :space, :tab'
       end
     end
 
@@ -238,199 +227,5 @@ module Sass
         @id
       end
     end
-
-    # Helper class that maintains render state
-    class Renderer
-      def initialize(data:,
-                     file:,
-                     indented_syntax:,
-                     include_paths:,
-                     output_style:,
-                     source_map:,
-                     out_file:,
-                     functions:,
-                     importer:)
-        raise ArgumentError, 'either data or file must be set' if file.nil? && data.nil?
-
-        @data = data
-        @file = file
-        @indented_syntax = indented_syntax
-        @include_paths = include_paths
-        @output_style = output_style
-        @source_map = source_map
-        @out_file = out_file
-        @global_functions = functions.keys
-        @functions = functions.transform_keys do |key|
-          key.to_s.split('(')[0].chomp
-        end
-        @importer = importer
-        @import_responses = {}
-      end
-
-      def compile_request(id)
-        EmbeddedProtocol::InboundMessage::CompileRequest.new(
-          id: id,
-          string: string,
-          path: path,
-          style: style,
-          source_map: source_map,
-          importers: importers,
-          global_functions: global_functions,
-          alert_color: $stderr.tty?,
-          alert_ascii: Platform::OS == 'windows'
-        )
-      end
-
-      def canonicalize_response(canonicalize_request)
-        url = Util.file_uri(File.absolute_path(canonicalize_request.url, (@file.nil? ? 'stdin' : @file)))
-
-        begin
-          result = @importer[canonicalize_request.importer_id].call canonicalize_request.url, @file
-          raise result if result.is_a? StandardError
-        rescue StandardError => e
-          return EmbeddedProtocol::InboundMessage::CanonicalizeResponse.new(
-            id: canonicalize_request.id,
-            error: e.message
-          )
-        end
-
-        if result&.key? :contents
-          @import_responses[url] = EmbeddedProtocol::InboundMessage::ImportResponse.new(
-            id: canonicalize_request.id,
-            success: EmbeddedProtocol::InboundMessage::ImportResponse::ImportSuccess.new(
-              contents: result[:contents],
-              syntax: EmbeddedProtocol::Syntax::SCSS,
-              source_map_url: nil
-            )
-          )
-          EmbeddedProtocol::InboundMessage::CanonicalizeResponse.new(
-            id: canonicalize_request.id,
-            url: url
-          )
-        elsif result&.key? :file
-          canonicalized_url = Util.file_uri(result[:file])
-
-          # TODO: FileImportRequest is not supported yet.
-          # Workaround by reading contents and return it when server asks
-          @import_responses[canonicalized_url] = EmbeddedProtocol::InboundMessage::ImportResponse.new(
-            id: canonicalize_request.id,
-            success: EmbeddedProtocol::InboundMessage::ImportResponse::ImportSuccess.new(
-              contents: File.read(result[:file]),
-              syntax: EmbeddedProtocol::Syntax::SCSS,
-              source_map_url: nil
-            )
-          )
-
-          EmbeddedProtocol::InboundMessage::CanonicalizeResponse.new(
-            id: canonicalize_request.id,
-            url: canonicalized_url
-          )
-        else
-          EmbeddedProtocol::InboundMessage::CanonicalizeResponse.new(
-            id: canonicalize_request.id
-          )
-        end
-      end
-
-      def import_response(import_request)
-        url = import_request.url
-
-        if @import_responses.key? url
-          @import_responses[url].id = import_request.id
-        else
-          @import_responses[url] = EmbeddedProtocol::InboundMessage::ImportResponse.new(
-            id: import_request.id,
-            error: "Failed to import: #{url}"
-          )
-        end
-
-        @import_responses[url]
-      end
-
-      def function_call_response(function_call_request)
-        EmbeddedProtocol::InboundMessage::FunctionCallResponse.new(
-          id: function_call_request.id,
-          success: @functions[function_call_request.name].call(*function_call_request.arguments)
-        )
-      rescue StandardError => e
-        EmbeddedProtocol::InboundMessage::FunctionCallResponse.new(
-          id: function_call_request.id,
-          error: e.message
-        )
-      end
-
-      private
-
-      def syntax
-        if @indented_syntax == true
-          EmbeddedProtocol::Syntax::INDENTED
-        else
-          EmbeddedProtocol::Syntax::SCSS
-        end
-      end
-
-      def url
-        return if @file.nil?
-
-        Util.file_uri @file
-      end
-
-      def string
-        return if @data.nil?
-
-        EmbeddedProtocol::InboundMessage::CompileRequest::StringInput.new(
-          source: @data,
-          url: url,
-          syntax: syntax
-        )
-      end
-
-      def path
-        @file if @data.nil?
-      end
-
-      def style
-        case @output_style&.to_sym
-        when :expanded
-          EmbeddedProtocol::OutputStyle::EXPANDED
-        when :compressed
-          EmbeddedProtocol::OutputStyle::COMPRESSED
-        when :nested, :compact
-          raise ArgumentError, "#{@output_style} is not a supported output_style"
-        else
-          raise ArgumentError, "#{@output_style} is not a valid utput_style"
-        end
-      end
-
-      def source_map
-        @source_map.is_a?(String) || (@source_map == true && !@out_file.nil?)
-      end
-
-      attr_reader :global_functions
-
-      # Order
-      # 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.
-      def importers
-        custom_importers = @importer.map.with_index do |_, id|
-          EmbeddedProtocol::InboundMessage::CompileRequest::Importer.new(
-            importer_id: id
-          )
-        end
-
-        include_path_importers = @include_paths
-                                 .concat(Sass.include_paths)
-                                 .map do |include_path|
-          EmbeddedProtocol::InboundMessage::CompileRequest::Importer.new(
-            path: File.absolute_path(include_path)
-          )
-        end
-
-        custom_importers.concat include_path_importers
-      end
-    end
   end
 end

data/lib/sass/error.rb

@@ -1,21 +1,23 @@
 # frozen_string_literal: true
 
 module Sass
-  class SassError < StandardError; end
+  class Error < StandardError; end
 
-  class ProtocolError < SassError; end
+  class ProtocolError < Error; end
 
-  # The error returned by {Sass.render}
-  class RenderError < SassError
-    attr_accessor :formatted, :file, :line, :column, :status
+  # The {Error} raised by {Embedded#render}.
+  class RenderError < Error
+    include Struct
+
+    attr_reader :formatted, :file, :line, :column, :status
 
     def initialize(message, formatted, file, line, column, status)
+      super(message)
       @formatted = formatted
       @file = file
       @line = line
       @column = column
       @status = status
-      super(message)
     end
 
     def backtrace

data/lib/sass/info.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Sass
+  # The {Observer} for {Embedded#info}.
+  class Version < Observer
+    def initialize(transport, id)
+      super(transport, id)
+      @transport.send EmbeddedProtocol::InboundMessage::VersionRequest.new(id: @id)
+    end
+
+    def update(error, message)
+      raise error unless error.nil?
+
+      case message
+      when EmbeddedProtocol::ProtocolError
+        raise ProtocolError, message.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
+end

data/lib/sass/observer.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Sass
+  # The {Observer} for receiving messages from {Transport}.
+  class Observer
+    def initialize(transport, id)
+      raise NotImplementedError if instance_of? Observer
+
+      @transport = transport
+      @id = id
+      @mutex = Mutex.new
+      @condition_variable = ConditionVariable.new
+      @error = nil
+      @message = nil
+      @transport.add_observer self
+    end
+
+    def fetch
+      @mutex.synchronize do
+        @condition_variable.wait(@mutex) if @error.nil? && @message.nil?
+      end
+
+      raise @error unless @error.nil?
+
+      @message
+    end
+
+    def update(error, message)
+      @transport.delete_observer self
+      @mutex.synchronize do
+        @error = error
+        @message = message
+        @condition_variable.broadcast
+      end
+    end
+  end
+end

data/lib/sass/render.rb

@@ -0,0 +1,242 @@
+# frozen_string_literal: true
+
+module Sass
+  # The {Observer} for {Embedded#render}.
+  class Render < Observer
+    def initialize(transport, id,
+                   data:,
+                   file:,
+                   indented_syntax:,
+                   include_paths:,
+                   output_style:,
+                   source_map:,
+                   out_file:,
+                   functions:,
+                   importer:)
+      raise ArgumentError, 'either data or file must be set' if file.nil? && data.nil?
+
+      super(transport, id)
+
+      @data = data
+      @file = file
+      @indented_syntax = indented_syntax
+      @include_paths = include_paths
+      @output_style = output_style
+      @source_map = source_map
+      @out_file = out_file
+      @global_functions = functions.keys
+      @functions = functions.transform_keys do |key|
+        key.to_s.split('(')[0].chomp
+      end
+      @importer = importer
+      @import_responses = {}
+
+      @transport.send compile_request
+    end
+
+    def update(error, message)
+      raise error unless error.nil?
+
+      case message
+      when EmbeddedProtocol::ProtocolError
+        raise ProtocolError, message.message
+      when EmbeddedProtocol::OutboundMessage::CompileResponse
+        return unless message.id == @id
+
+        Thread.new do
+          super(nil, message)
+        end
+      when EmbeddedProtocol::OutboundMessage::LogEvent
+        # not implemented yet
+      when EmbeddedProtocol::OutboundMessage::CanonicalizeRequest
+        return unless message['compilation_id'] == @id
+
+        Thread.new do
+          @transport.send canonicalize_response message
+        end
+      when EmbeddedProtocol::OutboundMessage::ImportRequest
+        return unless message['compilation_id'] == @id
+
+        Thread.new do
+          @transport.send import_response message
+        end
+      when EmbeddedProtocol::OutboundMessage::FileImportRequest
+        raise NotImplementedError, 'FileImportRequest is not implemented'
+      when EmbeddedProtocol::OutboundMessage::FunctionCallRequest
+        return unless message['compilation_id'] == @id
+
+        Thread.new do
+          @transport.send function_call_response message
+        end
+      end
+    rescue StandardError => e
+      Thread.new do
+        super(e, nil)
+      end
+    end
+
+    private
+
+    def compile_request
+      EmbeddedProtocol::InboundMessage::CompileRequest.new(
+        id: @id,
+        string: string,
+        path: path,
+        style: style,
+        source_map: source_map,
+        importers: importers,
+        global_functions: global_functions,
+        alert_color: $stderr.tty?,
+        alert_ascii: Platform::OS == 'windows'
+      )
+    end
+
+    def canonicalize_response(canonicalize_request)
+      url = Util.file_uri(File.absolute_path(canonicalize_request.url, (@file.nil? ? 'stdin' : @file)))
+
+      begin
+        result = @importer[canonicalize_request.importer_id].call canonicalize_request.url, @file
+        raise result if result.is_a? StandardError
+      rescue StandardError => e
+        return EmbeddedProtocol::InboundMessage::CanonicalizeResponse.new(
+          id: canonicalize_request.id,
+          error: e.message
+        )
+      end
+
+      if result&.key? :contents
+        @import_responses[url] = EmbeddedProtocol::InboundMessage::ImportResponse.new(
+          id: canonicalize_request.id,
+          success: EmbeddedProtocol::InboundMessage::ImportResponse::ImportSuccess.new(
+            contents: result[:contents],
+            syntax: EmbeddedProtocol::Syntax::SCSS,
+            source_map_url: nil
+          )
+        )
+        EmbeddedProtocol::InboundMessage::CanonicalizeResponse.new(
+          id: canonicalize_request.id,
+          url: url
+        )
+      elsif result&.key? :file
+        canonicalized_url = Util.file_uri(result[:file])
+
+        # TODO: FileImportRequest is not supported yet.
+        # Workaround by reading contents and return it when server asks
+        @import_responses[canonicalized_url] = EmbeddedProtocol::InboundMessage::ImportResponse.new(
+          id: canonicalize_request.id,
+          success: EmbeddedProtocol::InboundMessage::ImportResponse::ImportSuccess.new(
+            contents: File.read(result[:file]),
+            syntax: EmbeddedProtocol::Syntax::SCSS,
+            source_map_url: nil
+          )
+        )
+
+        EmbeddedProtocol::InboundMessage::CanonicalizeResponse.new(
+          id: canonicalize_request.id,
+          url: canonicalized_url
+        )
+      else
+        EmbeddedProtocol::InboundMessage::CanonicalizeResponse.new(
+          id: canonicalize_request.id
+        )
+      end
+    end
+
+    def import_response(import_request)
+      url = import_request.url
+
+      if @import_responses.key? url
+        @import_responses[url].id = import_request.id
+      else
+        @import_responses[url] = EmbeddedProtocol::InboundMessage::ImportResponse.new(
+          id: import_request.id,
+          error: "Failed to import: #{url}"
+        )
+      end
+
+      @import_responses[url]
+    end
+
+    def function_call_response(function_call_request)
+      EmbeddedProtocol::InboundMessage::FunctionCallResponse.new(
+        id: function_call_request.id,
+        success: @functions[function_call_request.name].call(*function_call_request.arguments)
+      )
+    rescue StandardError => e
+      EmbeddedProtocol::InboundMessage::FunctionCallResponse.new(
+        id: function_call_request.id,
+        error: e.message
+      )
+    end
+
+    def syntax
+      if @indented_syntax == true
+        EmbeddedProtocol::Syntax::INDENTED
+      else
+        EmbeddedProtocol::Syntax::SCSS
+      end
+    end
+
+    def url
+      return if @file.nil?
+
+      Util.file_uri @file
+    end
+
+    def string
+      return if @data.nil?
+
+      EmbeddedProtocol::InboundMessage::CompileRequest::StringInput.new(
+        source: @data,
+        url: url,
+        syntax: syntax
+      )
+    end
+
+    def path
+      @file if @data.nil?
+    end
+
+    def style
+      case @output_style&.to_sym
+      when :expanded
+        EmbeddedProtocol::OutputStyle::EXPANDED
+      when :compressed
+        EmbeddedProtocol::OutputStyle::COMPRESSED
+      else
+        raise ArgumentError, 'output_style must be one of :expanded, :compressed'
+      end
+    end
+
+    def source_map
+      @source_map.is_a?(String) || (@source_map == true && !@out_file.nil?)
+    end
+
+    attr_reader :global_functions
+
+    # Order
+    # 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.
+    def importers
+      custom_importers = @importer.map.with_index do |_, id|
+        EmbeddedProtocol::InboundMessage::CompileRequest::Importer.new(
+          importer_id: id
+        )
+      end
+
+      include_path_importers = @include_paths
+                               .concat(Sass.include_paths)
+                               .map do |include_path|
+        EmbeddedProtocol::InboundMessage::CompileRequest::Importer.new(
+          path: File.absolute_path(include_path)
+        )
+      end
+
+      custom_importers.concat include_path_importers
+    end
+  end
+end

data/lib/sass/result.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Sass
+  # The {Result} of {Embedded#render}.
+  class Result
+    include Struct
+
+    attr_reader :css, :map, :stats
+
+    def initialize(css, map, stats)
+      @css = css
+      @map = map
+      @stats = stats
+    end
+
+    # The {Stats} of {Embedded#render}.
+    class Stats
+      include Struct
+
+      attr_reader :entry, :start, :end, :duration
+
+      def initialize(entry, start, finish, duration)
+        @entry = entry
+        @start = start
+        @end = finish
+        @duration = duration
+      end
+    end
+  end
+end

data/lib/sass/struct.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Sass
+  # The {Struct} module.
+  module Struct
+    def [](key)
+      instance_variable_get("@#{key}".to_sym)
+    end
+
+    def to_h
+      instance_variables.map do |variable|
+        [variable[1..].to_sym, instance_variable_get(variable)]
+      end.to_h
+    end
+
+    def to_s
+      to_h.to_s
+    end
+  end
+end

data/lib/sass/transport.rb

@@ -5,9 +5,9 @@ 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
+  # The {Observable} {Transport} for low level communication with
+  # `dart-sass-embedded` using protocol buffers via stdio. Received messages
+  # can be observed by an {Observer}.
   class Transport
     include Observable
 
@@ -17,45 +17,31 @@ module Sass
 
     PROTOCOL_ERROR_ID = 4_294_967_295
 
+    ONEOF_MESSAGE = EmbeddedProtocol::InboundMessage
+                    .descriptor
+                    .lookup_oneof('message')
+                    .collect do |field_descriptor|
+      [field_descriptor.subtype, field_descriptor.name]
+    end.to_h
+
     def initialize
-      @stdin_semaphore = Mutex.new
-      @observerable_semaphore = Mutex.new
+      @observerable_mutex = Mutex.new
+      @stdin_mutex = Mutex.new
       @stdin, @stdout, @stderr, @wait_thread = Open3.popen3(DART_SASS_EMBEDDED)
       pipe @stderr, $stderr
       receive
     end
 
-    def send(req, 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, 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)
+    def add_observer(*args)
+      @observerable_mutex.synchronize do
+        super(*args)
       end
+    end
 
-      raise error if error
-
-      res
+    def send(message)
+      write EmbeddedProtocol::InboundMessage.new(
+        ONEOF_MESSAGE[message.class.descriptor] => message
+      ).to_proto
     end
 
     def close
@@ -66,6 +52,10 @@ module Sass
       nil
     end
 
+    def closed?
+      @stdin.closed?
+    end
+
     private
 
     def receive
@@ -78,10 +68,11 @@ module Sass
             bits += 7
             break if byte <= 0x7f
           end
-          changed
           payload = @stdout.read length
-          @observerable_semaphore.synchronize do
-            notify_observers nil, EmbeddedProtocol::OutboundMessage.decode(payload)
+          message = EmbeddedProtocol::OutboundMessage.decode payload
+          @observerable_mutex.synchronize do
+            changed
+            notify_observers nil, message[message.message.to_s]
           end
         rescue Interrupt
           break
@@ -100,7 +91,7 @@ module Sass
         rescue Interrupt
           break
         rescue IOError => e
-          @observerable_semaphore.synchronize do
+          @observerable_mutex.synchronize do
             notify_observers e, nil
           end
           close
@@ -110,7 +101,7 @@ module Sass
     end
 
     def write(payload)
-      @stdin_semaphore.synchronize do
+      @stdin_mutex.synchronize do
         length = payload.length
         while length.positive?
           @stdin.write ((length > 0x7f ? 0x80 : 0) | (length & 0x7f)).chr
@@ -119,32 +110,5 @@ module Sass
         @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,7 +1,9 @@
 # frozen_string_literal: true
 
+require 'pathname'
+
 module Sass
-  # Utilities functions
+  # The {Util} module.
   module Util
     module_function
 

data/lib/sass/version.rb

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

data/sass-embedded.gemspec

@@ -11,7 +11,7 @@ Gem::Specification.new do |spec|
   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.homepage      = 'https://github.com/ntkme/sass-embedded-host-ruby'
   spec.license       = 'MIT'
 
   spec.files         = `git ls-files -z`.split("\x0")
@@ -19,7 +19,7 @@ Gem::Specification.new do |spec|
   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.6'
+  spec.required_ruby_version = '>= 2.6.0'
 
   spec.require_paths = ['lib']
 

data/test/functions_test.rb

@@ -12,6 +12,8 @@ module Sass
       @embedded.close
     end
 
+    # rubocop:disable Layout/LineLength
+
     def render(sass)
       @embedded.render(data: sass,
                        functions: {
@@ -163,6 +165,8 @@ module Sass
                        })[:css]
     end
 
+    # rubocop:enable Layout/LineLength
+
     def test_functions_may_return_sass_string_type
       assert_sass <<-SCSS, <<-CSS
         div { url: url(sass_return_path("foo.svg")); }

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sass-embedded
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.6.1
 platform: ruby
 authors:
 - なつき
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-05-27 00:00:00.000000000 Z
+date: 2021-05-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: google-protobuf
@@ -157,7 +157,12 @@ files:
 - lib/sass.rb
 - lib/sass/embedded.rb
 - lib/sass/error.rb
+- lib/sass/info.rb
+- lib/sass/observer.rb
 - lib/sass/platform.rb
+- lib/sass/render.rb
+- lib/sass/result.rb
+- lib/sass/struct.rb
 - lib/sass/transport.rb
 - lib/sass/util.rb
 - lib/sass/version.rb
@@ -173,7 +178,7 @@ files:
 - test/render_test.rb
 - test/source_maps_test.rb
 - test/test_helper.rb
-homepage: https://github.com/ntkme/embedded-host-ruby
+homepage: https://github.com/ntkme/sass-embedded-host-ruby
 licenses:
 - MIT
 metadata: {}
@@ -185,7 +190,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '2.6'
+      version: 2.6.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="