sass-embedded 0.4.2 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c03a96231c8305e27f3deb1a35e308808482159a5dd25b4c8191da9c1b25500d
-  data.tar.gz: d6ba46dd80433759554a8c83d1fe8a8b4fd66461ffb063c859011d4ab4e3b6cc
+  metadata.gz: d1086f5483670120b40e9741187e5150a5af9e9ad5d38159d6d57459edec350b
+  data.tar.gz: d6afead31f102a04ad4d11c82e1381b597c285ae0206564640763173e2b67fc6
 SHA512:
-  metadata.gz: a4be81866a1672fd02da1cf1c66d08a2a0dd50cb002ee1b6fd0cce4d70c4e02222c11662a69307e7e33c58bf1dedc968d7ec72b2ebb3fa35296b1520896be2f5
-  data.tar.gz: 39b348a11dd2277bb43e7bd936b08462057caac6180cb5b0548384cb64da47d1255606d8ce0a0ab2d0a4d891efee26cff190568eec1a782426011c4fc15ac2b0
+  metadata.gz: c8c534da41310d6b7e6228624d26a6e3dd94bccc4b67b2e9a25bff82251cb3b4a5d312c58ec1e498f944731cc99f4fdcb66b117278640cee2fc3d81f95924f66
+  data.tar.gz: 6d8808fc65dbb7fc4b43976beb6c8573635d874e9d72a7949f20eda5406e582ea0933a99f844256ec284e3ecf1e8e6f02b967f50854fde661470bf6834550abb

data/.rubocop.yml

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

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 will download all the dependencies
+  # during gem installation, and the Makefile will unpack all downloaded
+  # dependencies. By default it will download 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,6 +1,7 @@
 # frozen_string_literal: true
 
-# The Sass module
+# The Sass module. This module will communicate 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
@@ -29,12 +30,14 @@ module Sass
       embedded.info
     end
 
-    # The global render methods. This method automatically instantiates a
+    # The global render method. 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}.
+    # `:render` method on the instance thereafter. See {Sass::Embedded#render}
+    # for supported options.
     # @example
-    #   Sass.render(options)
+    #   Sass.render(data: 'h1 { font-size: 40px; }')
+    # @example
+    #   Sass.render(file: 'style.css')
     # @return [Hash]
     def render(**kwargs)
       embedded.render(**kwargs)
@@ -55,5 +58,7 @@ require_relative 'sass/error'
 require_relative 'sass/platform'
 require_relative 'sass/util'
 require_relative 'sass/transport'
-require_relative 'sass/context'
+require_relative 'sass/observer'
+require_relative 'sass/info'
+require_relative 'sass/render'
 require_relative 'sass/embedded'

data/lib/sass/embedded.rb

@@ -1,10 +1,16 @@
 # frozen_string_literal: true
 
-require 'json'
 require 'base64'
+require 'json'
 
 module Sass
-  # The interface for using dart-sass-embedded
+  # The {Embedded} user interface for using dart-sass-embedded. Each instance
+  # will create 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
@@ -13,7 +19,7 @@ module Sass
     end
 
     def info
-      @info ||= InfoContext.new(@transport, next_id).fetch
+      @info ||= Info.new(@transport, next_id).fetch
     end
 
     def render(data: nil,
@@ -40,41 +46,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
+      result = 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 result.failure
         raise RenderError.new(
-          response.failure.message,
-          response.failure.formatted,
-          if response.failure.span.nil?
+          result.failure.message,
+          result.failure.formatted,
+          if result.failure.span.nil?
             nil
-          elsif response.failure.span.url == ''
+          elsif result.failure.span.url == ''
             'stdin'
           else
-            Util.path(response.failure.span.url)
+            Util.path(result.failure.span.url)
           end,
-          response.failure.span ? response.failure.span.start.line + 1 : nil,
-          response.failure.span ? response.failure.span.start.column + 1 : nil,
+          result.failure.span ? result.failure.span.start.line + 1 : nil,
+          result.failure.span ? result.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: result.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: result.success.css,
                              indent_type: indent_type,
                              indent_width: indent_width,
                              linefeed: linefeed,
@@ -186,7 +192,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 +225,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

@@ -5,7 +5,7 @@ module Sass
 
   class ProtocolError < SassError; end
 
-  # The error returned by {Sass.render}
+  # The error returned by {Embedded#render}.
   class RenderError < SassError
     attr_accessor :formatted, :file, :line, :column, :status
 

data/lib/sass/info.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Sass
+  # The {Observer} for {Embedded#info}.
+  class Info < 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,36 @@
 # frozen_string_literal: true
 
 module Sass
-  # An abstract context for maintaining state and observing transport
-  class Context
+  # The abstract {Observer} for tracking state and observing 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
       @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/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

@@ -3,7 +3,7 @@
 require 'pathname'
 
 module Sass
-  # Utilities functions
+  # The utilitiy module.
   module Util
     module_function
 

data/lib/sass/version.rb

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

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.2
+  version: 0.5.0
 platform: ruby
 authors:
 - なつき
@@ -155,10 +155,12 @@ 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/transport.rb
 - lib/sass/util.rb
 - lib/sass/version.rb