sass-embedded 0.13.4 → 0.16.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 891f4a0e1dbda14a01b411167cc6c9e6e0a73bd42b4a5ac903335619da08f95e
-  data.tar.gz: 97371b93430f4232eb68d9e5e1b4d15b9f75246ed530935e525160d383f5ec88
+  metadata.gz: 0ecdaedc0510249bc9b8e7da46e0b786a607153db705b5224214d5a2ef407f2a
+  data.tar.gz: 91ea0069f066bad0693367290eee7242f10b2514ba6502b3682bdfccfd3fe9d5
 SHA512:
-  metadata.gz: 0c4aabe5670786260198093754baaf57a4142894829a2242af0db4268394794b302fce042050e396f3dc495be1036a5df29cf73e47ea1dd661236f3d55692db6
-  data.tar.gz: 87ebbf21f8c9c87c662b0eca0010d008ec62aab94653059cbc64af607737544413154c3b88133c63c4eec11e15e4175fb05844d3371de44b966aa7382c5a52c4
+  metadata.gz: 1549a6a67863a7d3f3604a3f084fea4721540cbe9ffc9919505b0e71e6eac751eb5e6fa096673234307c6930962cef79ab5ba796c9c9c690fe157a8a3c580857
+  data.tar.gz: d98d4678e005203209feb31d1af90b842aef964dc7771cfd3ebc22a2e7558a9929cb014d750c8b9bfb9b8725c3d9764ac3da93bab0695ea9a46c32879f93ff77

data/ext/sass/extconf.rb

@@ -7,10 +7,61 @@ require 'mkmf'
 require 'open-uri'
 require_relative '../../lib/sass/embedded/compiler/path'
 require_relative '../../lib/sass/embedded/compiler/requirements'
-require_relative '../../lib/sass/embedded/platform'
 
 module Sass
   class Embedded
+    module Platform
+      OS = case RbConfig::CONFIG['host_os'].downcase
+           when /linux/
+             'linux'
+           when /darwin/
+             'darwin'
+           when /freebsd/
+             'freebsd'
+           when /netbsd/
+             'netbsd'
+           when /openbsd/
+             'openbsd'
+           when /dragonfly/
+             'dragonflybsd'
+           when /sunos|solaris/
+             'solaris'
+           when *Gem::WIN_PATTERNS
+             'windows'
+           else
+             RbConfig::CONFIG['host_os'].downcase
+           end
+
+      OSVERSION = RbConfig::CONFIG['host_os'].gsub(/[^\d]/, '').to_i
+
+      CPU = RbConfig::CONFIG['host_cpu']
+
+      ARCH = case CPU.downcase
+             when /amd64|x86_64|x64/
+               'x86_64'
+             when /i\d86|x86|i86pc/
+               'i386'
+             when /ppc64|powerpc64/
+               'powerpc64'
+             when /ppc|powerpc/
+               'powerpc'
+             when /sparcv9|sparc64/
+               'sparcv9'
+             when /arm64|aarch64/ # MacOS calls it "arm64", other operating systems "aarch64"
+               'aarch64'
+             when /^arm/
+               if OS == 'darwin' # Ruby before 3.0 reports "arm" instead of "arm64" as host_cpu on darwin
+                 'aarch64'
+               else
+                 'arm'
+               end
+             else
+               RbConfig::CONFIG['host_cpu']
+             end
+    end
+
+    private_constant :Platform
+
     # The dependency downloader. This downloads all the dependencies during gem
     # installation. The companion Makefile then unpacks all downloaded
     # dependencies. By default it downloads the release of each dependency

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)
@@ -145,170 +137,23 @@ module Sass
           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)
+                      url: @url&.to_s,
+                      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
-
-        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/path.rb

@@ -1,12 +1,10 @@
 # frozen_string_literal: true
 
-require_relative '../platform'
-
 module Sass
   class Embedded
     class Compiler
       PATH = File.absolute_path(
-        "../../../../ext/sass/sass_embedded/dart-sass-embedded#{Platform::OS == 'windows' ? '.bat' : ''}", __dir__
+        "../../../../ext/sass/sass_embedded/dart-sass-embedded#{Gem.win_platform? ? '.bat' : ''}", __dir__
       )
     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