sass-embedded 0.14.0 → 0.16.2

data/lib/sass/embedded/compile_context.rb

@@ -1,9 +1,5 @@
 # frozen_string_literal: true
 
-require_relative '../embedded_protocol'
-require_relative '../logger/source_span'
-require_relative 'observer'
-
 module Sass
   class Embedded
     # The {Observer} for {Embedded#compile}.
@@ -31,38 +27,33 @@ module Sass
                      logger:,
                      quiet_deps:,
                      verbose:)
-        @path = path
-        @source = source
-
-        @importer = to_struct(importer)
-        @load_paths = load_paths
-        @syntax = syntax
-        @url = url
-
-        @source_map = source_map
-        @source_map_include_sources = source_map_include_sources
-        @style = style
-
-        @global_functions = functions.keys.map(&:to_s)
-
-        @functions = functions.transform_keys do |key|
-          key.to_s.split('(')[0].chomp
-        end
-        @importers = importers.map do |obj|
-          to_struct(obj)
-        end
-
-        @alert_ascii = alert_ascii
-        @alert_color = alert_color
-
-        @logger = to_struct(logger)
-
-        @quiet_deps = quiet_deps
-        @verbose = verbose
+        @function_registery = FunctionRegistry.new(functions)
+        @importer_registery = ImporterRegistry.new(importers, load_paths)
+        @logger_registery = LoggerRegistry.new(logger)
 
         super(channel)
 
-        send_message compile_request
+        send_message EmbeddedProtocol::InboundMessage::CompileRequest.new(
+          id: id,
+          string: unless source.nil?
+                    EmbeddedProtocol::InboundMessage::CompileRequest::StringInput.new(
+                      source: source,
+                      url: url&.to_s,
+                      syntax: Protofier.to_proto_syntax(syntax),
+                      importer: importer.nil? ? nil : @importer_registery.register(importer)
+                    )
+                  end,
+          path: path,
+          style: Protofier.to_proto_output_style(style),
+          source_map: source_map,
+          source_map_include_sources: source_map_include_sources,
+          importers: @importer_registery.importers,
+          global_functions: @function_registery.global_functions,
+          alert_ascii: alert_ascii,
+          alert_color: alert_color,
+          quiet_deps: quiet_deps,
+          verbose: verbose
+        )
       end
 
       def update(error, message)
@@ -78,30 +69,30 @@ module Sass
         when EmbeddedProtocol::OutboundMessage::LogEvent
           return unless message.compilation_id == id
 
-          log message
+          @logger_registery.log message
         when EmbeddedProtocol::OutboundMessage::CanonicalizeRequest
           return unless message.compilation_id == id
 
           Thread.new do
-            send_message canonicalize_response message
+            send_message @importer_registery.canonicalize message
           end
         when EmbeddedProtocol::OutboundMessage::ImportRequest
           return unless message.compilation_id == id
 
           Thread.new do
-            send_message import_response message
+            send_message @importer_registery.import message
           end
         when EmbeddedProtocol::OutboundMessage::FileImportRequest
           return unless message.compilation_id == id
 
           Thread.new do
-            send_message file_import_response message
+            send_message @importer_registery.file_import message
           end
         when EmbeddedProtocol::OutboundMessage::FunctionCallRequest
           return unless message.compilation_id == id
 
           Thread.new do
-            send_message function_call_response message
+            send_message @function_registery.function_call message
           end
         end
       rescue StandardError => e
@@ -109,206 +100,8 @@ module Sass
           super(e, nil)
         end
       end
-
-      private
-
-      def log(event)
-        case event.type
-        when :DEBUG
-          if @logger.respond_to? :debug
-            @logger.debug(event.message, span: Logger::SourceSpan.from_proto(event.span))
-          else
-            Kernel.warn(event.formatted)
-          end
-        when :DEPRECATION_WARNING
-          if @logger.respond_to? :warn
-            @logger.warn(event.message, deprecation: true,
-                                        span: Logger::SourceSpan.from_proto(event.span),
-                                        stack: event.stack_trace)
-          else
-            Kernel.warn(event.formatted)
-          end
-        when :WARNING
-          if @logger.respond_to? :warn
-            @logger.warn(event.message, deprecation: false,
-                                        span: Logger::SourceSpan.from_proto(event.span),
-                                        stack: event.stack_trace)
-          else
-            Kernel.warn(event.formatted)
-          end
-        end
-      end
-
-      def compile_request
-        EmbeddedProtocol::InboundMessage::CompileRequest.new(
-          id: id,
-          string: unless @source.nil?
-                    EmbeddedProtocol::InboundMessage::CompileRequest::StringInput.new(
-                      source: @source,
-                      url: @url,
-                      syntax: to_proto_syntax(@syntax),
-                      importer: @importer.nil? ? nil : to_proto_importer(@importer, @importers.length)
-                    )
-                  end,
-          path: @path,
-          style: to_proto_output_style(@style),
-          source_map: @source_map,
-          source_map_include_sources: @source_map_include_sources,
-          importers: to_proto_importers(@importers, @load_paths),
-          global_functions: @global_functions,
-          alert_ascii: @alert_ascii,
-          alert_color: @alert_color
-        )
-      end
-
-      def canonicalize_response(canonicalize_request)
-        importer = importer_of_id canonicalize_request.importer_id
-        url = importer.canonicalize canonicalize_request.url,
-                                    from_import: canonicalize_request.from_import
-
-        EmbeddedProtocol::InboundMessage::CanonicalizeResponse.new(
-          id: canonicalize_request.id,
-          url: url
-        )
-      rescue StandardError => e
-        EmbeddedProtocol::InboundMessage::CanonicalizeResponse.new(
-          id: canonicalize_request.id,
-          error: e.message
-        )
-      end
-
-      def import_response(import_request)
-        importer = importer_of_id import_request.importer_id
-        importer_result = to_struct importer.load(import_request.url)
-
-        EmbeddedProtocol::InboundMessage::ImportResponse.new(
-          id: import_request.id,
-          success: EmbeddedProtocol::InboundMessage::ImportResponse::ImportSuccess.new(
-            contents: importer_result.contents,
-            syntax: to_proto_syntax(importer_result.syntax),
-            source_map_url: importer_result.respond_to?(:source_map_url) ? importer_result.source_map_url : nil
-          )
-        )
-      rescue StandardError => e
-        EmbeddedProtocol::InboundMessage::ImportResponse.new(
-          id: import_request.id,
-          error: e.message
-        )
-      end
-
-      def file_import_response(file_import_request)
-        importer = importer_of_id file_import_request.importer_id
-        file_url = importer.find_file_url file_import_request.url,
-                                          from_import: file_import_request.from_import
-
-        raise "file_url must be a file: URL, was \"#{file_url}\"" if !file_url.nil? && !file_url.start_with?('file:')
-
-        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.message
-        )
-      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),
-          accessed_argument_lists: function_call_request.arguments
-          .filter { |argument| argument.value == :argument_list }
-          .map { |argument| argument.argument_list.id }
-        )
-      rescue StandardError => e
-        EmbeddedProtocol::InboundMessage::FunctionCallResponse.new(
-          id: function_call_request.id,
-          error: e.message
-        )
-      end
-
-      def to_proto_syntax(syntax)
-        case syntax&.to_sym
-        when :scss
-          EmbeddedProtocol::Syntax::SCSS
-        when :indented
-          EmbeddedProtocol::Syntax::INDENTED
-        when :css
-          EmbeddedProtocol::Syntax::CSS
-        else
-          raise ArgumentError, 'syntax must be one of :scss, :indented, :css'
-        end
-      end
-
-      def to_proto_output_style(style)
-        case style&.to_sym
-        when :expanded
-          EmbeddedProtocol::OutputStyle::EXPANDED
-        when :compressed
-          EmbeddedProtocol::OutputStyle::COMPRESSED
-        else
-          raise ArgumentError, 'style must be one of :expanded, :compressed'
-        end
-      end
-
-      def to_proto_importer(importer, id)
-        is_importer = importer.respond_to?(:canonicalize) && importer.respond_to?(:load)
-        is_file_importer = importer.respond_to?(:find_file_url)
-
-        if is_importer && !is_file_importer
-          EmbeddedProtocol::InboundMessage::CompileRequest::Importer.new(
-            importer_id: id
-          )
-        elsif is_file_importer && !is_importer
-          EmbeddedProtocol::InboundMessage::CompileRequest::Importer.new(
-            file_importer_id: id
-          )
-        else
-          raise ArgumentError, 'importer must be an Importer or a FileImporter'
-        end
-      end
-
-      def to_proto_importers(importers, load_paths)
-        proto_importers = importers.map.with_index do |importer, id|
-          to_proto_importer(importer, id)
-        end
-
-        load_paths.each do |load_path|
-          proto_importers << EmbeddedProtocol::InboundMessage::CompileRequest::Importer.new(
-            path: File.absolute_path(load_path)
-          )
-        end
-
-        proto_importers
-      end
-
-      def importer_of_id(id)
-        if id == @importers.length
-          @importer
-        else
-          @importers[id]
-        end
-      end
-
-      def to_struct(obj)
-        return obj unless obj.is_a? Hash
-
-        struct = Object.new
-        obj.each do |key, value|
-          if value.respond_to? :call
-            struct.define_singleton_method key.to_sym do |*args, **kwargs|
-              value.call(*args, **kwargs)
-            end
-          else
-            struct.define_singleton_method key.to_sym do
-              value
-            end
-          end
-        end
-        struct
-      end
     end
+
+    private_constant :CompileContext
   end
 end

data/lib/sass/embedded/compiler/requirements.rb

@@ -3,7 +3,7 @@
 module Sass
   class Embedded
     class Compiler
-      REQUIREMENTS = '~> 1.49.7'
+      REQUIREMENTS = '~> 1.49.8'
     end
   end
 end

data/lib/sass/embedded/compiler.rb

@@ -2,9 +2,6 @@
 
 require 'observer'
 require 'open3'
-require_relative '../embedded_protocol'
-require_relative 'compiler/path'
-require_relative 'protocol_error'
 
 module Sass
   class Embedded
@@ -14,14 +11,7 @@ module Sass
     class Compiler
       include Observable
 
-      ONEOF_MESSAGE = EmbeddedProtocol::InboundMessage
-                      .descriptor
-                      .lookup_oneof('message')
-                      .to_h do |field_descriptor|
-        [field_descriptor.subtype, field_descriptor.name]
-      end
-
-      private_constant :ONEOF_MESSAGE
+      PROTOCOL_ERROR_ID = 4_294_967_295
 
       def initialize
         @observerable_mutex = Mutex.new
@@ -35,7 +25,7 @@ module Sass
           warn(@stderr.readline, uplevel: 1)
         end
         poll do
-          receive_proto read
+          receive_message Protofier.from_proto_message read
         end
       end
 
@@ -60,9 +50,7 @@ module Sass
       end
 
       def send_message(message)
-        write EmbeddedProtocol::InboundMessage.new(
-          ONEOF_MESSAGE[message.class.descriptor] => message
-        ).to_proto
+        write Protofier.to_proto_message message
       end
 
       def close
@@ -86,7 +74,7 @@ module Sass
       private
 
       def half_closed?
-        @id == EmbeddedProtocol::PROTOCOL_ERROR_ID
+        @id == PROTOCOL_ERROR_ID
       end
 
       def poll
@@ -108,9 +96,7 @@ module Sass
         end
       end
 
-      def receive_proto(proto)
-        payload = EmbeddedProtocol::OutboundMessage.decode(proto)
-        message = payload[payload.message.to_s]
+      def receive_message(message)
         case message
         when EmbeddedProtocol::ProtocolError
           raise ProtocolError, message.message
@@ -120,37 +106,18 @@ module Sass
       end
 
       def read
-        length = read_varint(@stdout)
+        length = Varint.read(@stdout)
         @stdout.read(length)
       end
 
       def write(payload)
         @stdin_mutex.synchronize do
-          write_varint(@stdin, payload.length)
-          @stdin.write payload
-        end
-      end
-
-      def read_varint(readable)
-        value = bits = 0
-        loop do
-          byte = readable.readbyte
-          value |= (byte & 0x7f) << bits
-          bits += 7
-          break if byte < 0x80
+          Varint.write(@stdin, payload.length)
+          @stdin.write(payload)
         end
-        value
-      end
-
-      def write_varint(writeable, value)
-        bytes = []
-        until value < 0x80
-          bytes << (0x80 | (value & 0x7f))
-          value >>= 7
-        end
-        bytes << value
-        writeable.write bytes.pack('C*')
       end
     end
+
+    private_constant :Compiler
   end
 end

data/lib/sass/embedded/{render.rb → legacy.rb}

@@ -3,9 +3,50 @@
 require 'base64'
 require 'json'
 require 'pathname'
-require_relative 'url'
+require 'uri'
 
+# The Sass module.
+#
+# This communicates with Embedded Dart Sass using the Embedded Sass protocol.
 module Sass
+  class << self
+    # @deprecated
+    # The global {.include_paths} for Sass files. This is meant for plugins and
+    # libraries to register the paths to their Sass stylesheets to that they may
+    # be included via `@import` or `@use`. This include path is used by every
+    # instance of {Sass::Embedded}. They are lower-precedence than any include
+    # paths passed in via the `include_paths` option.
+    #
+    # If the `SASS_PATH` environment variable is set,
+    # the initial value of `include_paths` will be initialized based on that.
+    # The variable should be a colon-separated list of path names
+    # (semicolon-separated on Windows).
+    #
+    # @example
+    #   Sass.include_paths << File.dirname(__FILE__) + '/sass'
+    # @return [Array]
+    def include_paths
+      Embedded.include_paths
+    end
+
+    # @deprecated
+    # The global {.render} method. This instantiates a global {Embedded} instance
+    # and calls {Embedded#render}.
+    #
+    # See {Embedded#render} for supported options.
+    #
+    # @example
+    #   Sass.render(data: 'h1 { font-size: 40px; }')
+    # @example
+    #   Sass.render(file: 'style.css')
+    # @return [Result]
+    # @raise [ProtocolError]
+    # @raise [RenderError]
+    def render(**kwargs)
+      instance.render(**kwargs)
+    end
+  end
+
   # The {Embedded} host for using dart-sass-embedded. Each instance creates
   # its own {Channel}.
   #
@@ -309,11 +350,17 @@ module Sass
         raise result if result.is_a? StandardError
 
         if result&.key? :contents
-          @importer_results[canonical_url] = ImporterResult.new(result[:contents], :scss)
+          @importer_results[canonical_url] = {
+            contents: result[:contents],
+            syntax: :scss
+          }
           canonical_url
         elsif result&.key? :file
           canonical_url = Url.path_to_file_url(File.absolute_path(result[:file]))
-          @importer_results[canonical_url] = ImporterResult.new(File.read(result[:file]), :scss)
+          @importer_results[canonical_url] = {
+            contents: File.read(result[:file]),
+            syntax: :scss
+          }
           canonical_url
         end
       end
@@ -323,6 +370,35 @@ module Sass
       end
     end
 
+    # @deprecated
+    # The {Url} module.
+    module Url
+      # The {::URI::Parser} that is in consistent with RFC 2396 (URI Generic Syntax) and dart:core library.
+      URI_PARSER = URI::Parser.new({ RESERVED: ';/?:@&=+$,' })
+
+      FILE_SCHEME = 'file://'
+
+      private_constant :URI_PARSER, :FILE_SCHEME
+
+      module_function
+
+      def path_to_file_url(path)
+        if File.absolute_path? path
+          URI_PARSER.escape "#{FILE_SCHEME}#{Gem.win_platform? ? '/' : ''}#{path}"
+        else
+          URI_PARSER.escape path
+        end
+      end
+
+      def file_url_to_path(url)
+        if url.start_with? FILE_SCHEME
+          URI_PARSER.unescape url[(FILE_SCHEME.length + (Gem.win_platform? ? 1 : 0))..]
+        else
+          URI_PARSER.unescape url
+        end
+      end
+    end
+
     private_constant :LegacyImporter
   end
 end

data/lib/sass/embedded/observer.rb

@@ -43,5 +43,7 @@ module Sass
         @subscription.send_message(*args)
       end
     end
+
+    private_constant :Observer
   end
 end

data/lib/sass/embedded/protofier.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+module Sass
+  class Embedded
+    # The {Protofier} between Pure Ruby types and Protobuf Ruby types.
+    module Protofier
+      ONEOF_MESSAGE = EmbeddedProtocol::InboundMessage
+                      .descriptor
+                      .lookup_oneof('message')
+                      .to_h do |field_descriptor|
+        [field_descriptor.subtype, field_descriptor.name]
+      end
+
+      private_constant :ONEOF_MESSAGE
+
+      module_function
+
+      def from_proto_compile_response(compile_response)
+        if compile_response.result == :failure
+          raise CompileError.new(
+            compile_response.failure.formatted || compile_response.failure.message,
+            compile_response.failure.message,
+            compile_response.failure.stack_trace,
+            from_proto_source_span(compile_response.failure.span)
+          )
+        end
+
+        CompileResult.new(
+          compile_response.success.css,
+          compile_response.success.source_map,
+          compile_response.success.loaded_urls
+        )
+      end
+
+      def from_proto_source_span(source_span)
+        return nil if source_span.nil?
+
+        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)
+      end
+
+      def from_proto_source_location(source_location)
+        return nil if source_location.nil?
+
+        Logger::SourceLocation.new(source_location.offset,
+                                   source_location.line,
+                                   source_location.column)
+      end
+
+      def from_proto_message(proto)
+        message = EmbeddedProtocol::OutboundMessage.decode(proto)
+        message.method(message.message).call
+      end
+
+      def to_proto_message(message)
+        EmbeddedProtocol::InboundMessage.new(
+          ONEOF_MESSAGE[message.class.descriptor] => message
+        ).to_proto
+      end
+
+      def to_proto_syntax(syntax)
+        case syntax&.to_sym
+        when :scss
+          EmbeddedProtocol::Syntax::SCSS
+        when :indented
+          EmbeddedProtocol::Syntax::INDENTED
+        when :css
+          EmbeddedProtocol::Syntax::CSS
+        else
+          raise ArgumentError, 'syntax must be one of :scss, :indented, :css'
+        end
+      end
+
+      def to_proto_output_style(style)
+        case style&.to_sym
+        when :expanded
+          EmbeddedProtocol::OutputStyle::EXPANDED
+        when :compressed
+          EmbeddedProtocol::OutputStyle::COMPRESSED
+        else
+          raise ArgumentError, 'style must be one of :expanded, :compressed'
+        end
+      end
+    end
+
+    private_constant :Protofier
+  end
+end

data/lib/sass/embedded/structifier.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Sass
+  class Embedded
+    # The {Structifier} that convert {::Hash} to {Struct}-like object.
+    module Structifier
+      module_function
+
+      def to_struct(obj)
+        return obj unless obj.is_a? Hash
+
+        struct = Object.new
+        obj.each do |key, value|
+          if value.respond_to? :call
+            struct.define_singleton_method key.to_sym do |*args, **kwargs|
+              value.call(*args, **kwargs)
+            end
+          else
+            struct.define_singleton_method key.to_sym do
+              value
+            end
+          end
+        end
+        struct
+      end
+    end
+
+    private_constant :Structifier
+  end
+end

data/lib/sass/embedded/varint.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Sass
+  class Embedded
+    # Read and write {Varint} from {::IO}.
+    module Varint
+      module_function
+
+      def read(readable)
+        value = bits = 0
+        loop do
+          byte = readable.readbyte
+          value |= (byte & 0x7f) << bits
+          bits += 7
+          break if byte < 0x80
+        end
+        value
+      end
+
+      def write(writeable, value)
+        bytes = []
+        until value < 0x80
+          bytes << (0x80 | (value & 0x7f))
+          value >>= 7
+        end
+        bytes << value
+        writeable.write bytes.pack('C*')
+      end
+    end
+
+    private_constant :Varint
+  end
+end