sass-embedded 0.3.0 → 0.6.0

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, res_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, res_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