sass-embedded 1.62.0 → 1.63.1

data/lib/sass/elf.rb

@@ -0,0 +1,276 @@
+# frozen_string_literal: true
+
+module Sass
+  # The {ELF} class.
+  #
+  # It parses ELF header to extract interpreter.
+  # @see https://github.com/torvalds/linux/blob/HEAD/include/uapi/linux/elf.h
+  # @see https://github.com/torvalds/linux/blob/HEAD/kernel/kexec_elf.c
+  class ELF
+    # rubocop:disable Naming/ConstantName
+
+    # 32-bit ELF base types.
+    Elf32_Addr  = :__u32
+    Elf32_Half  = :__u16
+    Elf32_Off   = :__u32
+    Elf32_Sword = :__s32
+    Elf32_Word  = :__u32
+
+    # 64-bit ELF base types.
+    Elf64_Addr   = :__u64
+    Elf64_Half   = :__u16
+    Elf64_SHalf  = :__s16
+    Elf64_Off    = :__u64
+    Elf64_Sword  = :__s32
+    Elf64_Word   = :__u32
+    Elf64_Xword  = :__u64
+    Elf64_Sxword = :__s64
+
+    # rubocop:enable Naming/ConstantName
+
+    # These constants are for the segment types stored in the image headers
+    PT_NULL         = 0
+    PT_LOAD         = 1
+    PT_DYNAMIC      = 2
+    PT_INTERP       = 3
+    PT_NOTE         = 4
+    PT_SHLIB        = 5
+    PT_PHDR         = 6
+    PT_TLS          = 7
+    PT_LOOS         = 0x60000000
+    PT_HIOS         = 0x6fffffff
+    PT_LOPROC       = 0x70000000
+    PT_HIPROC       = 0x7fffffff
+    PT_GNU_EH_FRAME = (PT_LOOS + 0x474e550)
+    PT_GNU_STACK    = (PT_LOOS + 0x474e551)
+    PT_GNU_RELRO    = (PT_LOOS + 0x474e552)
+    PT_GNU_PROPERTY = (PT_LOOS + 0x474e553)
+
+    # These constants define the different elf file types
+    ET_NONE   = 0
+    ET_REL    = 1
+    ET_EXEC   = 2
+    ET_DYN    = 3
+    ET_CORE   = 4
+    ET_LOPROC = 0xff00
+    ET_HIPROC = 0xffff
+
+    EI_NIDENT = 16
+
+    # rubocop:disable Naming/ConstantName
+
+    Elf32_Ehdr = [
+      [:unsigned_char, :e_ident, EI_NIDENT],
+      [Elf32_Half,     :e_type],
+      [Elf32_Half,     :e_machine],
+      [Elf32_Word,     :e_version],
+      [Elf32_Addr,     :e_entry],
+      [Elf32_Off,      :e_phoff],
+      [Elf32_Off,      :e_shoff],
+      [Elf32_Word,     :e_flags],
+      [Elf32_Half,     :e_ehsize],
+      [Elf32_Half,     :e_phentsize],
+      [Elf32_Half,     :e_phnum],
+      [Elf32_Half,     :e_shentsize],
+      [Elf32_Half,     :e_shnum],
+      [Elf32_Half,     :e_shstrndx]
+    ].freeze
+
+    Elf64_Ehdr = [
+      [:unsigned_char, :e_ident, EI_NIDENT],
+      [Elf64_Half,     :e_type],
+      [Elf64_Half,     :e_machine],
+      [Elf64_Word,     :e_version],
+      [Elf64_Addr,     :e_entry],
+      [Elf64_Off,      :e_phoff],
+      [Elf64_Off,      :e_shoff],
+      [Elf64_Word,     :e_flags],
+      [Elf64_Half,     :e_ehsize],
+      [Elf64_Half,     :e_phentsize],
+      [Elf64_Half,     :e_phnum],
+      [Elf64_Half,     :e_shentsize],
+      [Elf64_Half,     :e_shnum],
+      [Elf64_Half,     :e_shstrndx]
+    ].freeze
+
+    Elf32_Phdr = [
+      [Elf32_Word, :p_type],
+      [Elf32_Off,  :p_offset],
+      [Elf32_Addr, :p_vaddr],
+      [Elf32_Addr, :p_paddr],
+      [Elf32_Word, :p_filesz],
+      [Elf32_Word, :p_memsz],
+      [Elf32_Word, :p_flags],
+      [Elf32_Word, :p_align]
+    ].freeze
+
+    Elf64_Phdr = [
+      [Elf64_Word,  :p_type],
+      [Elf64_Word,  :p_flags],
+      [Elf64_Off,   :p_offset],
+      [Elf64_Addr,  :p_vaddr],
+      [Elf64_Addr,  :p_paddr],
+      [Elf64_Xword, :p_filesz],
+      [Elf64_Xword, :p_memsz],
+      [Elf64_Xword, :p_align]
+    ].freeze
+
+    # rubocop:enable Naming/ConstantName
+
+    # e_ident[] indexes
+    EI_MAG0    = 0
+    EI_MAG1    = 1
+    EI_MAG2    = 2
+    EI_MAG3    = 3
+    EI_CLASS   = 4
+    EI_DATA    = 5
+    EI_VERSION = 6
+    EI_OSABI   = 7
+    EI_PAD     = 8
+
+    # EI_MAG
+    ELFMAG0 = 0x7f
+    ELFMAG1 = 'E'.ord
+    ELFMAG2 = 'L'.ord
+    ELFMAG3 = 'F'.ord
+    ELFMAG  = [ELFMAG0, ELFMAG1, ELFMAG2, ELFMAG3].pack('C*')
+    SELFMAG = 4
+
+    # e_ident[EI_CLASS]
+    ELFCLASSNONE = 0
+    ELFCLASS32   = 1
+    ELFCLASS64   = 2
+    ELFCLASSNUM  = 3
+
+    # e_ident[EI_DATA]
+    ELFDATANONE = 0
+    ELFDATA2LSB = 1
+    ELFDATA2MSB = 2
+
+    def initialize(buffer)
+      @buffer = buffer
+      @ehdr = read_ehdr
+      @buffer.seek(@ehdr[:e_phoff], :SET)
+      @proghdrs = Array.new(@ehdr[:e_phnum]) do
+        read_phdr
+      end
+    end
+
+    def relocatable?
+      @ehdr[:e_type] == ET_REL
+    end
+
+    def executable?
+      @ehdr[:e_type] == ET_EXEC
+    end
+
+    def shared_object?
+      @ehdr[:e_type] == ET_DYN
+    end
+
+    def core?
+      @ehdr[:e_type] == ET_CORE
+    end
+
+    def interpreter
+      phdr = @proghdrs.find { |p| p[:p_type] == PT_INTERP }
+      return if phdr.nil?
+
+      @buffer.seek(phdr[:p_offset], :SET)
+      interpreter = @buffer.read(phdr[:p_filesz])
+      raise ArgumentError unless interpreter.end_with?("\0")
+
+      interpreter.chomp!("\0")
+    end
+
+    private
+
+    def file_class
+      @ehdr[:e_ident][EI_CLASS]
+    end
+
+    def data_encoding
+      @ehdr[:e_ident][EI_DATA]
+    end
+
+    def read_ehdr
+      @ehdr = { e_ident: @buffer.read(EI_NIDENT).unpack('C*') }
+      raise ArgumentError unless @ehdr[:e_ident].slice(EI_MAG0, SELFMAG).pack('C*') == ELFMAG
+
+      case file_class
+      when ELFCLASS32
+        Elf32_Ehdr
+      when ELFCLASS64
+        Elf64_Ehdr
+      else
+        raise ArgumentError
+      end.drop(1).to_h do |field|
+        [field[1], read1(field[0])]
+      end.merge!(@ehdr)
+    end
+
+    def read_phdr
+      case file_class
+      when ELFCLASS32
+        Elf32_Phdr
+      when ELFCLASS64
+        Elf64_Phdr
+      else
+        raise ArgumentError
+      end.to_h do |field|
+        [field[1], read1(field[0])]
+      end
+    end
+
+    def explicit_endian
+      case data_encoding
+      when ELFDATA2LSB
+        '<'
+      when ELFDATA2MSB
+        '>'
+      else
+        raise ArgumentError
+      end
+    end
+
+    def read1(type)
+      case type
+      when :__u8
+        @buffer.read(1).unpack1('C')
+      when :__u16
+        @buffer.read(2).unpack1("S#{explicit_endian}")
+      when :__u32
+        @buffer.read(4).unpack1("L#{explicit_endian}")
+      when :__u64
+        @buffer.read(8).unpack1("Q#{explicit_endian}")
+      when :__s8
+        @buffer.read(1).unpack1('c')
+      when :__s16
+        @buffer.read(2).unpack1("s#{explicit_endian}")
+      when :__s32
+        @buffer.read(4).unpack1("l#{explicit_endian}")
+      when :__s64
+        @buffer.read(8).unpack1("q#{explicit_endian}")
+      else
+        raise ArgumentError
+      end
+    end
+
+    INTERPRETER = begin
+      proc_self_exe = '/proc/self/exe'
+      if File.exist?(proc_self_exe)
+        File.open(proc_self_exe, 'rb') do |file|
+          elf = ELF.new(file)
+          interpreter = elf.interpreter
+          if interpreter.nil? && elf.shared_object?
+            File.readlink(proc_self_exe)
+          else
+            interpreter
+          end
+        end
+      end
+    end
+  end
+
+  private_constant :ELF
+end

data/lib/sass/embedded/channel.rb

@@ -27,7 +27,7 @@ module Sass
         @mutex.synchronize do
           begin
             id = @dispatcher.subscribe(observer)
-          rescue EOFError
+          rescue Errno::EBUSY
             @dispatcher = Dispatcher.new
             id = @dispatcher.subscribe(observer)
           end
@@ -48,8 +48,8 @@ module Sass
           @dispatcher.unsubscribe(id)
         end
 
-        def send_message(...)
-          @dispatcher.send_message(...)
+        def send_proto(...)
+          @dispatcher.send_proto(...)
         end
       end
 

data/lib/sass/embedded/compiler.rb

@@ -6,10 +6,19 @@ module Sass
   class Embedded
     # The {Compiler} class.
     #
-    # It runs the `dart-sass-embedded` process.
+    # It runs the `sass --embedded` process.
     class Compiler
       def initialize
-        @stdin, @stdout, @stderr, @wait_thread = Open3.popen3(*COMMAND, chdir: __dir__)
+        @stdin, @stdout, @stderr, @wait_thread = begin
+          Open3.popen3(*CLI::COMMAND, '--embedded', chdir: __dir__)
+        rescue Errno::ENOENT
+          require_relative '../elf'
+
+          raise if ELF::INTERPRETER.nil?
+
+          Open3.popen3(ELF::INTERPRETER, *CLI::COMMAND, '--embedded', chdir: __dir__)
+        end
+
         @stdin.binmode
         @stdout.binmode
         @stdin_mutex = Mutex.new
@@ -40,17 +49,20 @@ module Sass
         end
       end
 
-      def write(payload)
+      def write(id, proto)
         @stdin_mutex.synchronize do
-          Varint.write(@stdin, payload.length)
-          @stdin.write(payload)
+          Varint.write(@stdin, Varint.length(id) + proto.length)
+          Varint.write(@stdin, id)
+          @stdin.write(proto)
         end
       end
 
       def read
         @stdout_mutex.synchronize do
           length = Varint.read(@stdout)
-          @stdout.read(length)
+          id = Varint.read(@stdout)
+          proto = @stdout.read(length - Varint.length(id))
+          return id, proto
         end
       end
     end

data/lib/sass/embedded/dispatcher.rb

@@ -6,23 +6,23 @@ module Sass
     #
     # It dispatches messages between mutliple instances of {Host} and a single {Compiler}.
     class Dispatcher
-      PROTOCOL_ERROR_ID = 0xffffffff
+      UINT_MAX = 0xffffffff
 
       def initialize
         @compiler = Compiler.new
         @observers = {}
-        @id = 0
+        @id = 1
         @mutex = Mutex.new
 
         Thread.new do
           loop do
-            receive_message
-          rescue IOError, Errno::EBADF => e
+            receive_proto
+          rescue IOError, Errno::EBADF, Errno::EPROTO => e
             @mutex.synchronize do
-              @id = PROTOCOL_ERROR_ID
+              @id = UINT_MAX
               @observers.values
             end.each do |observer|
-              observer.error e
+              observer.error(e)
             end
             break
           end
@@ -31,7 +31,7 @@ module Sass
 
       def subscribe(observer)
         @mutex.synchronize do
-          raise EOFError if @id == PROTOCOL_ERROR_ID
+          raise Errno::EBUSY if @id == UINT_MAX
 
           id = @id
           @id = id.next
@@ -46,10 +46,10 @@ module Sass
 
           return unless @observers.empty?
 
-          if @id == PROTOCOL_ERROR_ID
+          if @id == UINT_MAX
             close
           else
-            @id = 0
+            @id = 1
           end
         end
       end
@@ -62,33 +62,29 @@ module Sass
         @compiler.closed?
       end
 
-      def send_message(...)
-        inbound_message = EmbeddedProtocol::InboundMessage.new(...)
-        @compiler.write(inbound_message.to_proto)
+      def send_proto(...)
+        @compiler.write(...)
       end
 
       private
 
-      def receive_message
-        outbound_message = EmbeddedProtocol::OutboundMessage.decode(@compiler.read)
-        oneof = outbound_message.message
-        message = outbound_message.public_send(oneof)
-        case oneof
-        when :error
-          @mutex.synchronize do
-            @id = PROTOCOL_ERROR_ID
-            message.id == PROTOCOL_ERROR_ID ? @observers.values : [@observers[message.id]]
-          end.each do |observer|
-            observer.public_send(oneof, message)
-          end
-        when :compile_response, :version_response
+      def receive_proto
+        id, proto = @compiler.read
+        case id
+        when 1...UINT_MAX
+          @mutex.synchronize { @observers[id] }.receive_proto(proto)
+        when 0
+          outbound_message = EmbeddedProtocol::OutboundMessage.decode(proto)
+          oneof = outbound_message.message
+          message = outbound_message.public_send(oneof)
           @mutex.synchronize { @observers[message.id] }.public_send(oneof, message)
-        when :log_event, :canonicalize_request, :import_request, :file_import_request, :function_call_request
-          Thread.new(@mutex.synchronize { @observers[message.compilation_id] }) do |observer|
-            observer.public_send(oneof, message)
-          end
+        when UINT_MAX
+          outbound_message = EmbeddedProtocol::OutboundMessage.decode(proto)
+          oneof = outbound_message.message
+          message = outbound_message.public_send(oneof)
+          raise Errno::EPROTO, message.message
         else
-          raise ArgumentError, "Unknown OutboundMessage.message #{message}"
+          raise Errno::EPROTO
         end
       end
     end

data/lib/sass/embedded/host/logger_registry.rb

@@ -7,41 +7,44 @@ module Sass
       #
       # It stores logger and handles log events.
       class LoggerRegistry
-        attr_reader :logger
-
         def initialize(logger)
-          @logger = Structifier.to_struct(logger, :debug, :warn)
-        end
+          logger = Structifier.to_struct(logger, :debug, :warn)
 
-        def log(event)
-          case event.type
-          when :DEBUG
-            if logger.respond_to? :debug
+          if logger.respond_to?(:debug)
+            define_singleton_method(:debug) do |event|
               logger.debug(event.message,
                            span: Protofier.from_proto_source_span(event.span))
-            else
-              warn(event.formatted)
             end
-          when :DEPRECATION_WARNING
-            if logger.respond_to? :warn
-              logger.warn(event.message,
-                          deprecation: true,
-                          span: Protofier.from_proto_source_span(event.span),
-                          stack: event.stack_trace)
-            else
-              warn(event.formatted)
-            end
-          when :WARNING
-            if logger.respond_to? :warn
+          end
+
+          if logger.respond_to?(:warn) # rubocop:disable Style/GuardClause
+            define_singleton_method(:warn) do |event|
               logger.warn(event.message,
-                          deprecation: false,
+                          deprecation: event.type == :DEPRECATION_WARNING,
                           span: Protofier.from_proto_source_span(event.span),
                           stack: event.stack_trace)
-            else
-              warn(event.formatted)
             end
           end
         end
+
+        def log(event)
+          case event.type
+          when :DEBUG
+            debug(event)
+          when :DEPRECATION_WARNING, :WARNING
+            warn(event)
+          end
+        end
+
+        private
+
+        def debug(event)
+          Kernel.warn(event.formatted)
+        end
+
+        def warn(event)
+          Kernel.warn(event.formatted)
+        end
       end
 
       private_constant :LoggerRegistry

data/lib/sass/embedded/host.rb

@@ -40,7 +40,6 @@ module Sass
           @logger_registry = LoggerRegistry.new(logger)
 
           send_message(compile_request: EmbeddedProtocol::InboundMessage::CompileRequest.new(
-            id: id,
             string: unless source.nil?
                       EmbeddedProtocol::InboundMessage::CompileRequest::StringInput.new(
                         source: source,
@@ -67,8 +66,8 @@ module Sass
       end
 
       def version_request
-        version_response = await do
-          send_message(version_request: EmbeddedProtocol::InboundMessage::VersionRequest.new(
+        version_response = await0 do
+          send_message0(version_request: EmbeddedProtocol::InboundMessage::VersionRequest.new(
             id: id
           ))
         end
@@ -76,16 +75,23 @@ module Sass
         "sass-embedded\t#{version_response.implementation_version}"
       end
 
-      def log_event(message)
-        @logger_registry.log(message)
-      end
-
       def compile_response(message)
-        resolve(message)
+        @result = message
+        @queue.close
       end
 
       def version_response(message)
-        resolve(message)
+        @result = message
+        @queue.close
+      end
+
+      def error(message)
+        @error = message
+        @queue.close
+      end
+
+      def log_event(message)
+        @logger_registry.log(message)
       end
 
       def canonicalize_request(message)
@@ -104,35 +110,59 @@ module Sass
         send_message(function_call_response: @function_registry.function_call(message))
       end
 
-      def error(message)
-        reject(CompileError.new(message.message, nil, nil, nil))
+      def receive_proto(proto)
+        @queue.push(proto)
       end
 
       private
 
-      def await
+      def await0
         @connection = @channel.connect(self)
-        @async = Async.new
+        @queue = Queue.new
+
         yield
-        @async.await
+
+        @queue.pop
+
+        raise @error if @error
+
+        @result
       ensure
         @connection&.disconnect
       end
 
-      def resolve(value)
-        @async.resolve(value)
-      end
+      def await
+        @connection = @channel.connect(self)
+        @queue = Queue.new
+
+        yield
 
-      def reject(reason)
-        @async.reject(reason)
+        while (proto = @queue.pop)
+          outbound_message = EmbeddedProtocol::OutboundMessage.decode(proto)
+          oneof = outbound_message.message
+          message = outbound_message.public_send(oneof)
+          public_send(oneof, message)
+        end
+
+        raise @error if @error
+
+        @result
+      ensure
+        @connection&.disconnect
       end
 
       def id
         @connection.id
       end
 
+      def send_message0(...)
+        inbound_message = EmbeddedProtocol::InboundMessage.new(...)
+        @connection.send_proto(0, inbound_message.to_proto)
+      end
+
       def send_message(...)
-        @connection.send_message(...)
+        inbound_message = EmbeddedProtocol::InboundMessage.new(...)
+        @connection.send_proto(id, inbound_message.to_proto)
       end
     end
 

data/lib/sass/embedded/protofier.rb

@@ -15,15 +15,16 @@ module Sass
         when :failure
           raise CompileError.new(
             result.message,
-            result.formatted,
-            result.stack_trace,
-            from_proto_source_span(result.span)
+            result.formatted == '' ? nil : result.formatted,
+            result.stack_trace == '' ? nil : result.stack_trace,
+            from_proto_source_span(result.span),
+            compile_response.loaded_urls
           )
         when :success
           CompileResult.new(
             result.css,
-            result.source_map,
-            result.loaded_urls
+            result.source_map == '' ? nil : result.source_map,
+            compile_response.loaded_urls
           )
         else
           raise ArgumentError, "Unknown CompileResponse.result #{result}"
@@ -36,8 +37,8 @@ module Sass
         Logger::SourceSpan.new(from_proto_source_location(source_span.start),
                                from_proto_source_location(source_span.end),
                                source_span.text,
-                               source_span.url,
-                               source_span.context)
+                               source_span.url == '' ? nil : source_span.url,
+                               source_span.context == '' ? nil : source_span.context)
       end
 
       def from_proto_source_location(source_location)

data/lib/sass/embedded/varint.rb

@@ -8,6 +8,12 @@ module Sass
     module Varint
       module_function
 
+      def length(value)
+        return 1 if value < 128
+
+        (value.bit_length + 6) / 7
+      end
+
       def read(readable)
         value = bits = 0
         loop do

data/lib/sass/embedded/version.rb

@@ -2,6 +2,6 @@
 
 module Sass
   class Embedded
-    VERSION = '1.62.0'
+    VERSION = '1.63.1'
   end
 end