sass-embedded 1.58.3-x86-linux-android

data/lib/sass/compile_error.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Sass
+  # An exception thrown because a Sass compilation failed.
+  class CompileError < StandardError
+    # @return [String, nil]
+    attr_accessor :sass_stack
+
+    # @return [Logger::SourceSpan, nil]
+    attr_accessor :span
+
+    def initialize(message, full_message, sass_stack, span)
+      super(message)
+      @full_message = full_message == '' ? nil : full_message.dup
+      @sass_stack = sass_stack == '' ? nil : sass_stack
+      @span = span
+    end
+
+    # @return [String]
+    def full_message(*args, **kwargs)
+      if @full_message.nil?
+        super(*args, **kwargs)
+      else
+        @full_message
+      end
+    end
+  end
+end

data/lib/sass/compile_result.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Sass
+  # The result of compiling Sass to CSS. Returned by {Sass.compile} and {Sass.compile_string}.
+  #
+  # @see https://sass-lang.com/documentation/js-api/interfaces/CompileResult
+  class CompileResult
+    # @return [String]
+    attr_reader :css
+
+    # @return [String, nil]
+    attr_reader :source_map
+
+    # @return [Array<String>]
+    attr_reader :loaded_urls
+
+    def initialize(css, source_map, loaded_urls)
+      @css = css
+      @source_map = source_map == '' ? nil : source_map
+      @loaded_urls = loaded_urls
+    end
+  end
+end

data/lib/sass/embedded/async.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module Sass
+  class Embedded
+    # The {Async} class.
+    #
+    # It awaits until the promise is resolved or rejected.
+    class Async
+      module State
+        PENDING = 0
+        FULFILLED = 1
+        REJECTED = 2
+      end
+
+      private_constant :State
+
+      def initialize
+        @result = nil
+        @state = State::PENDING
+
+        @condition_variable = ConditionVariable.new
+        @mutex = Mutex.new
+      end
+
+      def resolve(value)
+        @mutex.synchronize do
+          return unless @state == State::PENDING
+
+          @result = value
+          @state = State::FULFILLED
+          @condition_variable.broadcast
+        end
+      end
+
+      def reject(reason)
+        @mutex.synchronize do
+          return unless @state == State::PENDING
+
+          @result = reason
+          @state = State::REJECTED
+          @condition_variable.broadcast
+        end
+      end
+
+      def await
+        @mutex.synchronize do
+          @condition_variable.wait(@mutex) if @state == State::PENDING
+
+          raise @result if @state == State::REJECTED
+
+          @result
+        end
+      end
+    end
+
+    private_constant :Async
+  end
+end

data/lib/sass/embedded/channel.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module Sass
+  class Embedded
+    # The {Channel} class.
+    #
+    # It establishes connection between {Host} and {Dispatcher}.
+    class Channel
+      def initialize
+        @dispatcher = Dispatcher.new
+        @mutex = Mutex.new
+      end
+
+      def close
+        @mutex.synchronize do
+          @dispatcher.close
+        end
+      end
+
+      def closed?
+        @mutex.synchronize do
+          @dispatcher.closed?
+        end
+      end
+
+      def connect(observer)
+        @mutex.synchronize do
+          begin
+            id = @dispatcher.subscribe(observer)
+          rescue EOFError
+            @dispatcher = Dispatcher.new
+            id = @dispatcher.subscribe(observer)
+          end
+          Connection.new(@dispatcher, id)
+        end
+      end
+
+      # The {Connection} between {Host} to {Dispatcher}.
+      class Connection
+        attr_reader :id
+
+        def initialize(dispatcher, id)
+          @dispatcher = dispatcher
+          @id = id
+        end
+
+        def disconnect
+          @dispatcher.unsubscribe(id)
+        end
+
+        def send_message(**kwargs)
+          @dispatcher.send_message(**kwargs)
+        end
+      end
+
+      private_constant :Connection
+    end
+
+    private_constant :Channel
+  end
+end

data/lib/sass/embedded/compiler.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+require 'open3'
+
+module Sass
+  class Embedded
+    # The {Compiler} class.
+    #
+    # It runs the `dart-sass-embedded` process.
+    class Compiler
+      def initialize
+        @stdin, @stdout, @stderr, @wait_thread = Open3.popen3(*COMMAND, chdir: __dir__)
+        @stdin.binmode
+        @stdout.binmode
+        @stdin_mutex = Mutex.new
+        @stdout_mutex = Mutex.new
+
+        Thread.new do
+          loop do
+            warn(@stderr.readline, uplevel: 1)
+          rescue IOError, Errno::EBADF
+            break
+          end
+        end
+      end
+
+      def close
+        @stdin_mutex.synchronize do
+          @stdin.close unless @stdin.closed?
+          @stdout.close unless @stdout.closed?
+          @stderr.close unless @stderr.closed?
+        end
+
+        @wait_thread.value
+      end
+
+      def closed?
+        @stdin_mutex.synchronize do
+          @stdin.closed?
+        end
+      end
+
+      def write(payload)
+        @stdin_mutex.synchronize do
+          Varint.write(@stdin, payload.length)
+          @stdin.write(payload)
+        end
+      end
+
+      def read
+        @stdout_mutex.synchronize do
+          length = Varint.read(@stdout)
+          @stdout.read(length)
+        end
+      end
+    end
+
+    private_constant :Compiler
+  end
+end

data/lib/sass/embedded/dispatcher.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+module Sass
+  class Embedded
+    # The {Dispatcher} class.
+    #
+    # It dispatches messages between mutliple instances of {Host} and a single {Compiler}.
+    class Dispatcher
+      PROTOCOL_ERROR_ID = 0xffffffff
+
+      def initialize
+        @compiler = Compiler.new
+        @observers = {}
+        @id = 0
+        @mutex = Mutex.new
+
+        Thread.new do
+          loop do
+            receive_message
+          rescue IOError, Errno::EBADF => e
+            @mutex.synchronize do
+              @id = PROTOCOL_ERROR_ID
+              @observers.values
+            end.each do |observer|
+              observer.error e
+            end
+            break
+          end
+        end
+      end
+
+      def subscribe(observer)
+        @mutex.synchronize do
+          raise EOFError if @id == PROTOCOL_ERROR_ID
+
+          id = @id
+          @id = id.next
+          @observers[id] = observer
+          id
+        end
+      end
+
+      def unsubscribe(id)
+        @mutex.synchronize do
+          @observers.delete(id)
+
+          return unless @observers.empty?
+
+          if @id == PROTOCOL_ERROR_ID
+            close
+          else
+            @id = 0
+          end
+        end
+      end
+
+      def close
+        @compiler.close
+      end
+
+      def closed?
+        @compiler.closed?
+      end
+
+      def send_message(**kwargs)
+        inbound_message = EmbeddedProtocol::InboundMessage.new(**kwargs)
+        @compiler.write(inbound_message.to_proto)
+      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
+          @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
+        else
+          raise ArgumentError, "Unknown OutboundMessage.message #{message}"
+        end
+      end
+    end
+
+    private_constant :Dispatcher
+  end
+end

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

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+module Sass
+  class Embedded
+    class Host
+      # The {FunctionRegistry} class.
+      #
+      # It stores sass custom functions and handles function calls.
+      class FunctionRegistry
+        attr_reader :global_functions
+
+        def initialize(functions, alert_color:)
+          functions = functions.transform_keys(&:to_s)
+
+          @global_functions = functions.keys
+          @functions_by_name = functions.transform_keys do |signature|
+            index = signature.index('(')
+            if index
+              signature.slice(0, index)
+            else
+              signature
+            end
+          end
+
+          @id = 0
+          @functions_by_id = {}
+          @ids_by_function = {}
+
+          @highlight = alert_color
+        end
+
+        def register(function)
+          return if @ids_by_function.key?(function)
+
+          id = @id
+          @id = id.next
+
+          @ids_by_function[function] = id
+          @functions_by_id[id] = function
+
+          id
+        end
+
+        def function_call(function_call_request)
+          arguments = function_call_request.arguments.map do |argument|
+            value_protofier.from_proto(argument)
+          end
+
+          success = value_protofier.to_proto(get(function_call_request).call(arguments))
+          accessed_argument_lists = arguments
+                                    .select do |argument|
+                                      argument.is_a?(Sass::Value::ArgumentList) && argument.instance_eval do
+                                        @keywords_accessed
+                                      end
+                                    end
+                                    .map { |argument| argument.instance_eval { @id } }
+
+          EmbeddedProtocol::InboundMessage::FunctionCallResponse.new(
+            id: function_call_request.id,
+            success: success,
+            accessed_argument_lists: accessed_argument_lists
+          )
+        rescue StandardError => e
+          EmbeddedProtocol::InboundMessage::FunctionCallResponse.new(
+            id: function_call_request.id,
+            error: e.full_message(highlight: @highlight, order: :top)
+          )
+        end
+
+        private
+
+        def get(function_call_request)
+          case function_call_request.identifier
+          when :name
+            @functions_by_name[function_call_request.name]
+          when :function_id
+            @functions_by_id[function_call_request.function_id]
+          end
+        end
+
+        def value_protofier
+          @value_protofier ||= ValueProtofier.new(self)
+        end
+      end
+
+      private_constant :FunctionRegistry
+    end
+  end
+end

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

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+module Sass
+  class Embedded
+    class Host
+      # The {ImporterRegistry} class.
+      #
+      # It stores importers and handles import requests.
+      class ImporterRegistry
+        attr_reader :importers
+
+        def initialize(importers, load_paths, alert_color:)
+          @id = 0
+          @importers_by_id = {}
+          @importers = importers
+                       .map { |importer| register(importer) }
+                       .concat(
+                         load_paths.map do |load_path|
+                           EmbeddedProtocol::InboundMessage::CompileRequest::Importer.new(
+                             path: File.absolute_path(load_path)
+                           )
+                         end
+                       )
+
+          @highlight = alert_color
+        end
+
+        def register(importer)
+          importer = Structifier.to_struct(importer, :canonicalize, :load, :find_file_url)
+
+          is_importer = importer.respond_to?(:canonicalize) && importer.respond_to?(:load)
+          is_file_importer = importer.respond_to?(:find_file_url)
+
+          raise ArgumentError, 'importer must be an Importer or a FileImporter' if is_importer == is_file_importer
+
+          id = @id
+          @id = id.next
+
+          @importers_by_id[id] = importer
+          if is_importer
+            EmbeddedProtocol::InboundMessage::CompileRequest::Importer.new(
+              importer_id: id
+            )
+          else
+            EmbeddedProtocol::InboundMessage::CompileRequest::Importer.new(
+              file_importer_id: id
+            )
+          end
+        end
+
+        def canonicalize(canonicalize_request)
+          importer = @importers_by_id[canonicalize_request.importer_id]
+          url = importer.canonicalize(canonicalize_request.url, from_import: canonicalize_request.from_import)&.to_s
+
+          EmbeddedProtocol::InboundMessage::CanonicalizeResponse.new(
+            id: canonicalize_request.id,
+            url: url
+          )
+        rescue StandardError => e
+          EmbeddedProtocol::InboundMessage::CanonicalizeResponse.new(
+            id: canonicalize_request.id,
+            error: e.full_message(highlight: @highlight, order: :top)
+          )
+        end
+
+        def import(import_request)
+          importer = @importers_by_id[import_request.importer_id]
+          importer_result = Structifier.to_struct importer.load(import_request.url), :contents, :syntax, :source_map_url
+
+          EmbeddedProtocol::InboundMessage::ImportResponse.new(
+            id: import_request.id,
+            success: EmbeddedProtocol::InboundMessage::ImportResponse::ImportSuccess.new(
+              contents: importer_result.contents,
+              syntax: Protofier.to_proto_syntax(importer_result.syntax),
+              source_map_url: (importer_result.source_map_url&.to_s if importer_result.respond_to?(:source_map_url))
+            )
+          )
+        rescue StandardError => e
+          EmbeddedProtocol::InboundMessage::ImportResponse.new(
+            id: import_request.id,
+            error: e.full_message(highlight: @highlight, order: :top)
+          )
+        end
+
+        def file_import(file_import_request)
+          importer = @importers_by_id[file_import_request.importer_id]
+          file_url = importer.find_file_url(file_import_request.url, from_import: file_import_request.from_import)&.to_s
+
+          EmbeddedProtocol::InboundMessage::FileImportResponse.new(
+            id: file_import_request.id,
+            file_url: file_url
+          )
+        rescue StandardError => e
+          EmbeddedProtocol::InboundMessage::FileImportResponse.new(
+            id: file_import_request.id,
+            error: e.full_message(highlight: @highlight, order: :top)
+          )
+        end
+      end
+
+      private_constant :ImporterRegistry
+    end
+  end
+end

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

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Sass
+  class Embedded
+    class Host
+      # The {LoggerRegistry} class.
+      #
+      # It stores logger and handles log events.
+      class LoggerRegistry
+        attr_reader :logger
+
+        def initialize(logger)
+          @logger = Structifier.to_struct(logger, :debug, :warn)
+        end
+
+        def log(event)
+          case event.type
+          when :DEBUG
+            if logger.respond_to? :debug
+              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
+              logger.warn(event.message,
+                          deprecation: false,
+                          span: Protofier.from_proto_source_span(event.span),
+                          stack: event.stack_trace)
+            else
+              warn(event.formatted)
+            end
+          end
+        end
+      end
+
+      private_constant :LoggerRegistry
+    end
+  end
+end