sass-embedded 0.15.0 → 0.16.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8b1ad905f18295ab48835d21b1e6a9c644a860154b37531eeaae2f50f16f70e9
-  data.tar.gz: 229fe63046318d8ce512683d11e3868e8c70d6b28897badeb74be7757ff63e7e
+  metadata.gz: 74339d550d532d1edc9ecb2cb8894a514c5519c71af3eb4a6e3066f09c3d02e4
+  data.tar.gz: b93e64c9e33a7a684a4cb4767e2bdd62b2a81f0dd636483d31b174ba16c0a088
 SHA512:
-  metadata.gz: 20bc3d260f0ac7bd9473351b7f59a08ccd1de7720afc56c027c83025924b7c986335994a4b257344e8c8435c11b5248de2d1dd512cf5e499d85eeddd1166f260
-  data.tar.gz: 5cd706afea71314dc85b47d58f3d4cb9f7ecc82a0a1ed72fc8afc5f772bd98022a8026b62eb490b7c2d9c74c1045d7edb945736078e5195f8c93f858d3f6cc7f
+  metadata.gz: a0aaddbc0bf954095bfa061e270eaa86e37409935ae180d1c13e97e3034eb89a913cce63f57c3d0dff2076ba17d03bd4516b058b809c702f31fc08fd40d6780c
+  data.tar.gz: 8a2317cbc80f5f6040e8d341e1f0eee67448547d2dd47b32e94caa5d869cfafc0a0b903e52b63a44f3bbec84178e072424a8a938dc0f568c42d3bffb1ee107ad

data/lib/sass/compile_error.rb

@@ -1,9 +1,7 @@
 # frozen_string_literal: true
 
-require_relative 'logger/source_span'
-
 module Sass
-  # The {CompileError} raised by {Embedded#compile} or {Embedded#compile_string}.
+  # An exception thrown because a Sass compilation failed.
   class CompileError < StandardError
     attr_accessor :sass_message, :sass_stack, :span
 
@@ -13,12 +11,5 @@ module Sass
       @sass_stack = sass_stack
       @span = span
     end
-
-    def self.from_proto(compile_failure)
-      CompileError.new(compile_failure.formatted,
-                       compile_failure.message,
-                       compile_failure.stack_trace,
-                       Logger::SourceSpan.from_proto(compile_failure.span))
-    end
   end
 end

data/lib/sass/compile_result.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module Sass
-  # The {CompileResult} of {Embedded#compile} or {Embedded#compile_string}.
+  # The result of compiling Sass to CSS. Returned by {Sass.compile} and {Sass.compile_string}.
   class CompileResult
     attr_reader :css, :source_map, :loaded_urls
 
@@ -10,9 +10,5 @@ module Sass
       @source_map = source_map == '' ? nil : source_map
       @loaded_urls = loaded_urls
     end
-
-    def self.from_proto(compile_success)
-      CompileResult.new(compile_success.css, compile_success.source_map, compile_success.loaded_urls)
-    end
   end
 end

data/lib/sass/embedded/channel.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require_relative 'compiler'
-
 module Sass
   class Embedded
     # The {Channel} for {Compiler} calls. Each instance creates its own
@@ -58,5 +56,7 @@ module Sass
 
       private_constant :Subscription
     end
+
+    private_constant :Channel
   end
 end

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

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+module Sass
+  class Embedded
+    class CompileContext
+      # The {FunctionRegistry} for {CompileContext}.
+      class FunctionRegistry
+        attr_reader :global_functions
+
+        def initialize(functions)
+          @global_functions = functions.keys
+          @functions_by_name = functions.transform_keys do |signature|
+            signature = signature.chomp
+            index = signature.index('(')
+            if index
+              signature.slice(0, index)
+            else
+              signature
+            end
+          end
+          @functions_by_id = {}
+          @ids_by_function = {}
+          @id = 0
+        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|
+            protofier.from_proto_value(argument)
+          end
+
+          success = protofier.to_proto_value(get(function_call_request).call(arguments))
+          accessed_argument_lists = arguments
+                                    .filter 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.message
+          )
+        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 protofier
+          @protofier ||= Protofier.new(self)
+        end
+      end
+
+      private_constant :FunctionRegistry
+    end
+  end
+end

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

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+module Sass
+  class Embedded
+    class CompileContext
+      # The {ImporterRegistry} for {CompileContext}.
+      class ImporterRegistry
+        attr_reader :importers
+
+        def initialize(importers, load_paths)
+          @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)
+        end
+
+        def register(importer)
+          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
+
+          proto = if is_importer
+                    EmbeddedProtocol::InboundMessage::CompileRequest::Importer.new(
+                      importer_id: @id
+                    )
+                  else
+                    EmbeddedProtocol::InboundMessage::CompileRequest::Importer.new(
+                      file_importer_id: @id
+                    )
+                  end
+          @importers_by_id[@id] = importer
+          @id = @id.next
+          proto
+        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.message
+          )
+        end
+
+        def import(import_request)
+          importer = @importers_by_id[import_request.importer_id]
+          importer_result = Protofier.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: Protofier.to_proto_syntax(importer_result.syntax),
+              source_map_url: importer_result.respond_to?(:source_map_url) ? importer_result.source_map_url&.to_s : nil
+            )
+          )
+        rescue StandardError => e
+          EmbeddedProtocol::InboundMessage::ImportResponse.new(
+            id: import_request.id,
+            error: e.message
+          )
+        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
+
+          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
+      end
+
+      private_constant :ImporterRegistry
+    end
+  end
+end

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}.
@@ -34,7 +30,6 @@ module Sass
         @path = path
         @source = source
 
-        @importer = to_struct(importer)
         @load_paths = load_paths
         @syntax = syntax
         @url = url
@@ -43,19 +38,16 @@ module Sass
         @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
+        @function_registery = FunctionRegistry.new(functions.transform_keys(&:to_s))
+        @importer_registery = ImporterRegistry.new(importers.map do |obj|
+          Protofier.to_struct(obj)
+        end, load_paths)
+        @importer = importer.nil? ? nil : @importer_registery.register(Protofier.to_struct(importer))
 
         @alert_ascii = alert_ascii
         @alert_color = alert_color
 
-        @logger = to_struct(logger)
+        @logger = Protofier.to_struct(logger)
 
         @quiet_deps = quiet_deps
         @verbose = verbose
@@ -83,25 +75,25 @@ module Sass
           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
@@ -116,14 +108,14 @@ module Sass
         case event.type
         when :DEBUG
           if @logger.respond_to? :debug
-            @logger.debug(event.message, span: Logger::SourceSpan.from_proto(event.span))
+            @logger.debug(event.message, span: Protofier.from_proto_source_span(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),
+                                        span: Protofier.from_proto_source_span(event.span),
                                         stack: event.stack_trace)
           else
             Kernel.warn(event.formatted)
@@ -131,7 +123,7 @@ module Sass
         when :WARNING
           if @logger.respond_to? :warn
             @logger.warn(event.message, deprecation: false,
-                                        span: Logger::SourceSpan.from_proto(event.span),
+                                        span: Protofier.from_proto_source_span(event.span),
                                         stack: event.stack_trace)
           else
             Kernel.warn(event.formatted)
@@ -146,167 +138,22 @@ module Sass
                     EmbeddedProtocol::InboundMessage::CompileRequest::StringInput.new(
                       source: @source,
                       url: @url&.to_s,
-                      syntax: to_proto_syntax(@syntax),
-                      importer: @importer.nil? ? nil : to_proto_importer(@importer, @importers.length)
+                      syntax: Protofier.to_proto_syntax(@syntax),
+                      importer: @importer
                     )
                   end,
           path: @path,
-          style: to_proto_output_style(@style),
+          style: Protofier.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,
+          importers: @importer_registery.importers,
+          global_functions: @function_registery.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)&.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.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&.to_s : 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)&.to_s
-
-        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
@@ -152,5 +138,7 @@ module Sass
         writeable.write bytes.pack('C*')
       end
     end
+
+    private_constant :Compiler
   end
 end

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

@@ -5,7 +5,48 @@ require 'json'
 require 'pathname'
 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}.
   #

data/lib/sass/embedded/observer.rb

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