sass-embedded 0.13.3 → 0.16.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 66553cec396e3756a62ded16038be4d37c891e4a12f29bd6eac3c29ca90f7a83
-  data.tar.gz: c417c5299585437b5b27a57577aeae2995cb259b3ff4f70225c554305a7233ca
+  metadata.gz: 74339d550d532d1edc9ecb2cb8894a514c5519c71af3eb4a6e3066f09c3d02e4
+  data.tar.gz: b93e64c9e33a7a684a4cb4767e2bdd62b2a81f0dd636483d31b174ba16c0a088
 SHA512:
-  metadata.gz: c48f41fd91c77065313d27677a90795c765ecf3ebbc2c50315e796a1ce7c57431e120691ad5205129a69f1dd6c5ff28aa5828a39bf24015acbfebf8306584a39
-  data.tar.gz: 183d281f59d7d91aaa9817a97574c13233e0c14f03fee68bc96f26383cf247dc38472a372c814ee4466fff8c6010e7c503bb612f5b0ebef9b846ff31ef4231cf
+  metadata.gz: a0aaddbc0bf954095bfa061e270eaa86e37409935ae180d1c13e97e3034eb89a913cce63f57c3d0dff2076ba17d03bd4516b058b809c702f31fc08fd40d6780c
+  data.tar.gz: 8a2317cbc80f5f6040e8d341e1f0eee67448547d2dd47b32e94caa5d869cfafc0a0b903e52b63a44f3bbec84178e072424a8a938dc0f568c42d3bffb1ee107ad

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 = 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
+        @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
 
-        %i[debug warn].each do |sym|
-          instance_variable_set("@#{sym}".to_sym, get_method(logger, sym))
-        end
+        @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
@@ -115,26 +107,26 @@ module Sass
       def log(event)
         case event.type
         when :DEBUG
-          if @debug.nil?
-            Kernel.warn(event.formatted)
+          if @logger.respond_to? :debug
+            @logger.debug(event.message, span: Protofier.from_proto_source_span(event.span))
           else
-            @debug.call(event.message, span: Logger::SourceSpan.from_proto(event.span))
+            Kernel.warn(event.formatted)
           end
         when :DEPRECATION_WARNING
-          if @warn.nil?
-            Kernel.warn(event.formatted)
+          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.call(event.message, deprecation: true,
-                                      span: Logger::SourceSpan.from_proto(event.span),
-                                      stack: event.stack_trace)
+            Kernel.warn(event.formatted)
           end
         when :WARNING
-          if @warn.nil?
-            Kernel.warn(event.formatted)
+          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.call(event.message, deprecation: false,
-                                      span: Logger::SourceSpan.from_proto(event.span),
-                                      stack: event.stack_trace)
+            Kernel.warn(event.formatted)
           end
         end
       end
@@ -145,178 +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_with_id(canonicalize_request.importer_id)
-        url = get_method(importer, :canonicalize).call 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_with_id(import_request.importer_id)
-        importer_result = get_method(importer, :load).call import_request.url
-
-        EmbeddedProtocol::InboundMessage::ImportResponse.new(
-          id: import_request.id,
-          success: EmbeddedProtocol::InboundMessage::ImportResponse::ImportSuccess.new(
-            contents: get_attr(importer_result, :contents),
-            syntax: to_proto_syntax(get_attr(importer_result, :syntax)),
-            source_map_url: get_attr(importer_result, :source_map_url)
-          )
-        )
-      rescue StandardError => e
-        EmbeddedProtocol::InboundMessage::ImportResponse.new(
-          id: import_request.id,
-          error: e.message
-        )
-      end
-
-      def file_import_response(file_import_request)
-        file_importer = importer_with_id(file_import_request.importer_id)
-        file_url = get_method(file_importer, :find_file_url).call 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 = get_method(importer, :canonicalize) && get_method(importer, :load)
-        is_file_importer = get_method(importer, :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_with_id(id)
-        if id == @importers.length
-          @importer
-        else
-          @importers[id]
-        end
-      end
-
-      def get_method(obj, sym)
-        sym = sym.to_sym
-        if obj.respond_to? sym
-          obj.method(sym)
-        elsif obj.is_a? Hash
-          if obj[sym].respond_to? :call
-            obj[sym]
-          elsif obj[sym.to_s].respond_to? :call
-            obj[sym.to_s]
-          end
-        end
-      end
-
-      def get_attr(obj, sym)
-        sym = sym.to_sym
-        if obj.respond_to? sym
-          obj.method(sym).call
-        elsif obj.is_a? Hash
-          if obj[sym]
-            obj[sym]
-          elsif obj[sym.to_s]
-            obj[sym.to_s]
-          end
-        end
-      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