sass-embedded 0.4.1 → 0.6.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 44a04b95b0d29cda95382a09cb00512ff6c2bb3f2c93b04f6171678856f648b7
-  data.tar.gz: 944fefc7cc7507a20ebea9154c412bd99cc5cf9e2d698d604bcf0dd71e287aeb
+  metadata.gz: 4d8fe5d208436fad17c2eb0b4542de995dff90b8fb69983b05db6d4519526ee5
+  data.tar.gz: d202c23bdca1b462fedda0284a9ea9a98103beacddcad969be5e0e9e0dbc24c0
 SHA512:
-  metadata.gz: a6088c2f97962305cea6dadcf4e5b5cb24d8332b9de55a2c42ebcc7c1929661d84dc40598e4167b5c74489eeeb898e8f47cdb638c0492a63c22124b7b14f1641
-  data.tar.gz: 2894b4ae45d5f2eea15d99a403b1641f6ec5192d79b06765b3c7d765aa11255c3513f2f754d8405a8c9b32dc51f6f6ace8caf928f412e6e1334c0d979c6ae0b8
+  metadata.gz: b512dcca31e35eec561f0a6b9dfab8c0d6232934d997e552ba4a1f3574ea9d3edb85ccb9b7ef6df4bfc85e486a05390d0301609515a05df9b05589c2e2348e41
+  data.tar.gz: 0a80a2df0b37ee916bb406b84d598c390d723a3d54500de9aed4b3fce7f129cdb047060442a0d47d4873b8954a88ca5c6b4d85d957a6e16806ada372adae2c5e

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,13 +1,14 @@
 # frozen_string_literal: true
 
-# The Sass module
+# The Sass module. This communicates with Embedded Dart Sass using
+# the Embedded Sass protocol.
 module Sass
   class << self
-    # The global include_paths for Sass files. This is meant for plugins and
+    # 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.
+    # 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.
@@ -16,7 +17,7 @@ module Sass
     #
     # @example
     #   Sass.include_paths << File.dirname(__FILE__) + '/sass'
-    # @return [Array<String, Pathname>]
+    # @return [Array]
     def include_paths
       @include_paths ||= if ENV['SASS_PATH']
                            ENV['SASS_PATH'].split(File::PATH_SEPARATOR)
@@ -25,17 +26,26 @@ module Sass
                          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 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}.
+    # 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(options)
-    # @return [Hash]
+    #   Sass.render(file: 'style.css')
+    # @return [Result]
+    # @raise [ProtocolError]
+    # @raise [RenderError]
     def render(**kwargs)
       embedded.render(**kwargs)
     end
@@ -50,10 +60,13 @@ module Sass
   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/context'
+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,20 +19,28 @@ module Sass
       @id = 0
     end
 
+    # The {Embedded#info} method.
+    #
+    # @raise [ProtocolError]
     def info
-      @info ||= InfoContext.new(@transport, next_id).fetch
+      @info ||= Version.new(@transport, next_id).message
     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,
@@ -40,41 +55,41 @@ module Sass
       indent_width = parse_indent_width(indent_width)
       linefeed = parse_linefeed(linefeed)
 
-      response = RenderContext.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 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).message
+
+      if message.failure
         raise RenderError.new(
-          response.failure.message,
-          response.failure.formatted,
-          if response.failure.span.nil?
+          message.failure.message,
+          message.failure.formatted,
+          if message.failure.span.nil?
             nil
-          elsif response.failure.span.url == ''
+          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,
@@ -86,16 +101,9 @@ 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
@@ -186,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
 
@@ -219,276 +227,5 @@ module Sass
         @id
       end
     end
-
-    # InfoContext
-    class InfoContext < Context
-      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?
-
-        response = message[message.message.to_s]
-
-        case response
-        when EmbeddedProtocol::ProtocolError
-          raise ProtocolError, response.message
-        when EmbeddedProtocol::OutboundMessage::VersionResponse
-          return unless response.id == @id
-
-          Thread.new do
-            super(nil, response)
-          end
-        end
-      rescue StandardError => e
-        Thread.new do
-          super(e, nil)
-        end
-      end
-    end
-
-    # RenderContext
-    class RenderContext < Context
-      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?
-
-        response = message[message.message.to_s]
-
-        case response
-        when EmbeddedProtocol::ProtocolError
-          raise ProtocolError, response.message
-        when EmbeddedProtocol::OutboundMessage::CompileResponse
-          return unless response.id == @id
-
-          Thread.new do
-            super(nil, response)
-          end
-        when EmbeddedProtocol::OutboundMessage::LogEvent
-          # not implemented yet
-        when EmbeddedProtocol::OutboundMessage::CanonicalizeRequest
-          return unless response['compilation_id'] == @id
-
-          Thread.new do
-            @transport.send canonicalize_response(response)
-          end
-        when EmbeddedProtocol::OutboundMessage::ImportRequest
-          return unless response['compilation_id'] == @id
-
-          Thread.new do
-            @transport.send import_response(response)
-          end
-        when EmbeddedProtocol::OutboundMessage::FileImportRequest
-          raise NotImplementedError, 'FileImportRequest is not implemented'
-        when EmbeddedProtocol::OutboundMessage::FunctionCallRequest
-          return unless response['compilation_id'] == @id
-
-          Thread.new do
-            @transport.send function_call_response(response)
-          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
-        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/{context.rb → observer.rb}

@@ -1,35 +1,35 @@
 # frozen_string_literal: true
 
 module Sass
-  # An abstract context for maintaining state and observing transport
-  class Context
+  # The {Observer} for receiving messages from {Transport}.
+  class Observer
     def initialize(transport, id)
-      raise NotImplementedError if instance_of? Context
+      raise NotImplementedError if instance_of? Observer
 
       @transport = transport
       @id = id
       @mutex = Mutex.new
       @condition_variable = ConditionVariable.new
-      @response = nil
       @error = nil
+      @message = nil
       @transport.add_observer self
     end
 
-    def fetch
+    def message
       @mutex.synchronize do
-        @condition_variable.wait(@mutex) if @error.nil? && @response.nil?
+        @condition_variable.wait(@mutex) if @error.nil? && @message.nil?
       end
 
       raise @error unless @error.nil?
 
-      @response
+      @message
     end
 
     def update(error, message)
       @transport.delete_observer self
       @mutex.synchronize do
         @error = error
-        @response = message
+        @message = message
         @condition_variable.broadcast
       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,24 +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 add_observer(*args)
-      @observerable_semaphore.synchronize do
+      @observerable_mutex.synchronize do
         super(*args)
       end
     end
 
-    def send(req)
-      req_kind = req.class.name.split('::').last.gsub(/\B(?=[A-Z])/, '_').downcase
-      message = EmbeddedProtocol::InboundMessage.new(req_kind => req)
-      write message.to_proto
+    def send(message)
+      write EmbeddedProtocol::InboundMessage.new(
+        ONEOF_MESSAGE[message.class.descriptor] => message
+      ).to_proto
     end
 
     def close
@@ -63,9 +70,9 @@ module Sass
           end
           payload = @stdout.read length
           message = EmbeddedProtocol::OutboundMessage.decode payload
-          @observerable_semaphore.synchronize do
+          @observerable_mutex.synchronize do
             changed
-            notify_observers nil, message
+            notify_observers nil, message[message.message.to_s]
           end
         rescue Interrupt
           break
@@ -84,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
@@ -94,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

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.1'
+  VERSION = '0.6.2'
 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")

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,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: sass-embedded
 version: !ruby/object:Gem::Version
-  version: 0.4.1
+  version: 0.6.2
 platform: ruby
 authors:
 - なつき
@@ -155,10 +155,14 @@ files:
 - ext/Makefile
 - ext/extconf.rb
 - lib/sass.rb
-- lib/sass/context.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
@@ -174,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: {}