sass-embedded 0.2.4 → 0.5.0

data/lib/sass/error.rb

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

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Sass
+  # The abstract {Observer} for tracking state and observing 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/transport.rb

@@ -5,20 +5,60 @@ require 'observer'
 require_relative '../../ext/embedded_sass_pb'
 
 module Sass
+  # 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
 
     DART_SASS_EMBEDDED = File.absolute_path(
-      "../../ext/sass_embedded/dart-sass-embedded#{Sass::Platform::OS == 'windows' ? '.bat' : ''}", __dir__
+      "../../ext/sass_embedded/dart-sass-embedded#{Platform::OS == 'windows' ? '.bat' : ''}", __dir__
     )
 
     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
+      @observerable_mutex = Mutex.new
+      @stdin_mutex = Mutex.new
       @stdin, @stdout, @stderr, @wait_thread = Open3.popen3(DART_SASS_EMBEDDED)
-      @stdin_semaphore = Mutex.new
-      @observerable_semaphore = Mutex.new
+      pipe @stderr, $stderr
+      receive
+    end
+
+    def add_observer(*args)
+      @observerable_mutex.synchronize do
+        super(*args)
+      end
+    end
+
+    def send(message)
+      write EmbeddedProtocol::InboundMessage.new(
+        ONEOF_MESSAGE[message.class.descriptor] => message
+      ).to_proto
+    end
+
+    def close
+      delete_observers
+      @stdin.close unless @stdin.closed?
+      @stdout.close unless @stdout.closed?
+      @stderr.close unless @stderr.closed?
+      nil
+    end
+
+    def closed?
+      @stdin.closed?
+    end
 
+    private
+
+    def receive
       Thread.new do
         loop do
           bits = length = 0
@@ -28,10 +68,11 @@ module Sass
             bits += 7
             break if byte <= 0x7f
           end
-          changed
           payload = @stdout.read length
-          @observerable_semaphore.synchronize do
-            notify_observers nil, Sass::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
@@ -41,14 +82,16 @@ module Sass
           break
         end
       end
+    end
 
+    def pipe(readable, writeable)
       Thread.new do
         loop do
-          warn @stderr.read
+          writeable.write readable.read
         rescue Interrupt
           break
         rescue IOError => e
-          @observerable_semaphore.synchronize do
+          @observerable_mutex.synchronize do
             notify_observers e, nil
           end
           close
@@ -57,82 +100,14 @@ module Sass
       end
     end
 
-    def send(req, id)
-      mutex = Mutex.new
-      resource = ConditionVariable.new
-
-      req_name = req.class.name.split('::').last.gsub(/\B(?=[A-Z])/, '_').downcase
-
-      message = Sass::EmbeddedProtocol::InboundMessage.new(req_name.to_sym => req)
-
-      error = nil
-      res = nil
-
-      @observerable_semaphore.synchronize do
-        MessageObserver.new self, id do |e, r|
-          mutex.synchronize do
-            error = e
-            res = r
-
-            resource.signal
-          end
-        end
-      end
-
-      mutex.synchronize do
-        write message.to_proto
-
-        resource.wait(mutex)
-      end
-
-      raise error if error
-
-      res
-    end
-
-    def close
-      delete_observers
-      @stdin.close unless @stdin.closed?
-      @stdout.close unless @stdout.closed?
-      @stderr.close unless @stderr.closed?
-      nil
-    end
-
-    private
-
-    def write(proto)
-      @stdin_semaphore.synchronize do
-        length = proto.length
+    def write(payload)
+      @stdin_mutex.synchronize do
+        length = payload.length
         while length.positive?
           @stdin.write ((length > 0x7f ? 0x80 : 0) | (length & 0x7f)).chr
           length >>= 7
         end
-        @stdin.write proto
-      end
-    end
-
-    class MessageObserver
-      def initialize(obs, id, &block)
-        @obs = obs
-        @id = id
-        @block = block
-        @obs.add_observer self
-      end
-
-      def update(error, message)
-        if error
-          @obs.delete_observer self
-          @block.call error, nil
-        elsif message.error&.id == Sass::Transport::PROTOCOL_ERROR_ID
-          @obs.delete_observer self
-          @block.call Sass::ProtocolError.new(message.error.message), nil
-        else
-          res = message[message.message.to_s]
-          if (res['compilation_id'] || res['id']) == @id
-            @obs.delete_observer self
-            @block.call error, res
-          end
-        end
+        @stdin.write payload
       end
     end
   end