sass-embedded 1.77.5 → 1.100.0

data/ext/sass/platform.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+# The {Platform} module.
+module Platform
+  HOST_CPU = RbConfig::CONFIG['host_cpu'].downcase
+
+  CPU = case HOST_CPU
+        when /amd64|x86_64|x64/
+          'x86_64'
+        when /i\d86|x86|i86pc/
+          'i386'
+        when /arm64|aarch64/
+          'aarch64'
+        when /arm/
+          'arm'
+        when /ppc64le|powerpc64le/
+          'ppc64le'
+        else
+          HOST_CPU
+        end
+
+  HOST_OS = RbConfig::CONFIG['host_os'].downcase
+
+  OS = case HOST_OS
+       when /darwin/
+         'darwin'
+       when /linux-android/
+         'linux-android'
+       when /linux-musl/
+         'linux-musl'
+       when /linux-none/
+         'linux-none'
+       when /linux-uclibc/
+         'linux-uclibc'
+       when /linux/
+         'linux'
+       when *Gem::WIN_PATTERNS
+         'windows'
+       else
+         HOST_OS
+       end
+
+  ARCH = "#{CPU}-#{OS}".freeze
+end

data/ext/sass/sass_config.rb

@@ -0,0 +1,183 @@
+# frozen_string_literal: true
+
+require_relative 'platform'
+
+# The {SassConfig} module.
+module SassConfig
+  module_function
+
+  def package_json(path = '.')
+    require 'json'
+
+    JSON.parse(File.read(File.absolute_path('package.json', path)))
+  end
+
+  def dart_sass_version
+    package_json(__dir__)['dependencies']['sass']
+      # TODO: remove after https://github.com/sass/dart-sass/pull/2413
+      .delete_prefix('file:sass-').delete_suffix('.tgz')
+  end
+
+  def dart_sass
+    repo = 'https://github.com/sass/dart-sass'
+
+    tag_name = dart_sass_version
+
+    message = "dart-sass for #{Platform::ARCH} not available at #{repo}/releases/tag/#{tag_name}"
+
+    env = ''
+
+    os = case Platform::OS
+         when 'darwin'
+           'macos'
+         when 'linux'
+           'linux'
+         when 'linux-android'
+           'android'
+         when 'linux-musl'
+           env = '-musl'
+           'linux'
+         when 'windows'
+           'windows'
+         else
+           raise NotImplementedError, message
+         end
+
+    cpu = case Platform::CPU
+          when 'x86_64'
+            'x64'
+          when 'aarch64'
+            'arm64'
+          when 'arm'
+            'arm'
+          when 'riscv64'
+            'riscv64'
+          else
+            raise NotImplementedError, message
+          end
+
+    ext = Platform::OS == 'windows' ? 'zip' : 'tar.gz'
+
+    "#{repo}/releases/download/#{tag_name}/dart-sass-#{tag_name}-#{os}-#{cpu}#{env}.#{ext}"
+  end
+
+  def protoc
+    repo = 'https://repo.maven.apache.org/maven2/com/google/protobuf/protoc'
+
+    dependency = Gem::Dependency.new('google-protobuf')
+
+    spec = dependency.to_spec
+
+    version = spec.version
+
+    message = "protoc for #{Platform::ARCH} not available at #{repo}/#{version}"
+
+    os = case Platform::OS
+         when 'darwin'
+           'osx'
+         when 'linux', 'linux-android', 'linux-musl', 'linux-none', 'linux-uclibc'
+           'linux'
+         when 'windows'
+           'windows'
+         else
+           raise NotImplementedError, message
+         end
+
+    cpu = case Platform::CPU
+          when 'i386'
+            'x86_32'
+          when 'x86_64'
+            'x86_64'
+          when 'aarch64'
+            Platform::OS == 'windows' ? 'x86_64' : 'aarch_64'
+          when 'ppc64le'
+            'ppcle_64'
+          when 's390x'
+            's390_64'
+          else
+            raise NotImplementedError, message
+          end
+
+    uri = "#{repo}/#{version}/protoc-#{version}-#{os}-#{cpu}.exe"
+
+    Utils.fetch_https("#{uri}.sha1")
+
+    uri
+  rescue Gem::RemoteFetcher::FetchError
+    dependency_request = Gem::Resolver::DependencyRequest.new(dependency, nil)
+
+    versions = Gem::Resolver::BestSet.new.find_all(dependency_request).filter_map do |s|
+      s.version if s.platform == Gem::Platform::RUBY
+    end
+
+    versions.sort.reverse_each do |v|
+      uri = "#{repo}/#{v}/protoc-#{v}-#{os}-#{cpu}.exe"
+
+      Utils.fetch_https("#{uri}.sha1")
+
+      return uri
+    rescue Gem::RemoteFetcher::FetchError
+      next
+    end
+
+    raise NotImplementedError, message
+  end
+
+  def embedded_sass_protocol
+    require 'json'
+
+    rubyarchdir = ENV.fetch('RUBYARCHDIR', nil)
+
+    rubylibdir = ENV.fetch('RUBYLIBDIR', nil)
+
+    version = Utils.capture(RbConfig.ruby,
+                            "-I#{File.absolute_path('../../lib', __dir__)}",
+                            *("-I#{rubyarchdir}" if rubyarchdir),
+                            *("-I#{rubylibdir}" if rubylibdir),
+                            File.absolute_path('../../exe/sass', __dir__),
+                            '--embedded',
+                            '--version')
+
+    tag_name = JSON.parse(version)['protocolVersion']
+
+    "https://github.com/sass/sass/raw/embedded-protocol-#{tag_name}/spec/embedded_sass.proto"
+  end
+
+  def development?
+    File.exist?('../../Gemfile')
+  end
+
+  def gem_version
+    require_relative '../../lib/sass/embedded/version'
+
+    development? ? dart_sass_version : Sass::Embedded::VERSION
+  end
+
+  def gem_platform
+    platform = Gem::Platform.new("#{Platform::CPU}-#{Platform::HOST_OS}")
+    case Platform::OS
+    when 'darwin'
+      case platform.cpu
+      when 'aarch64'
+        Gem::Platform.new(['arm64', platform.os])
+      else
+        platform
+      end
+    when 'linux'
+      if platform.version&.start_with?('gnu')
+        platform
+      else
+        Gem::Platform.new([platform.cpu, platform.os, "gnu#{platform.version}"])
+      end
+    when 'windows'
+      case platform.cpu
+      when 'x86_64'
+        Gem::Platform.new('x64-mingw-ucrt')
+      else
+        Gem::Platform.new([platform.cpu, 'mingw', 'ucrt'])
+      end
+    else
+      platform
+    end
+  end
+end

data/ext/sass/utils.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+# The {Utils} module.
+module Utils
+  module_function
+
+  def capture(...)
+    require 'open3'
+
+    stdout, stderr, status = Open3.capture3(...)
+
+    raise stderr unless status.success?
+
+    stdout
+  end
+
+  def fetch_https(source_uri)
+    require 'rubygems/remote_fetcher'
+
+    source_uri = begin
+      Gem::Uri.parse!(source_uri)
+    rescue NoMethodError
+      URI.parse(source_uri)
+    end
+
+    Gem::RemoteFetcher.fetcher.fetch_https(source_uri)
+  end
+
+  def windows_system_directory
+    path = capture('powershell.exe',
+                   '-NoLogo',
+                   '-NoProfile',
+                   '-NonInteractive',
+                   '-Command',
+                   '[Environment]::GetFolderPath([Environment+SpecialFolder]::System) | Write-Host -NoNewline')
+
+    File.absolute_path(path)
+  end
+end

data/lib/sass/compiler/channel.rb

@@ -6,9 +6,11 @@ module Sass
     #
     # It manages the lifecycle of {Dispatcher}.
     class Channel
-      def initialize(dispatcher_class)
-        @dispatcher_class = dispatcher_class
-        @dispatcher = @dispatcher_class.new
+      def initialize(*args, **kwargs, &block)
+        @args = args
+        @kwargs = kwargs
+        @block = block
+        @dispatcher = Dispatcher.new(*@args, **@kwargs, &@block)
         @mutex = Mutex.new
       end
 
@@ -33,7 +35,7 @@ module Sass
 
           Stream.new(@dispatcher, host)
         rescue Errno::EBUSY
-          @dispatcher = @dispatcher_class.new
+          @dispatcher = Dispatcher.new(*@args, **@kwargs, &@block)
           Stream.new(@dispatcher, host)
         end
       end

data/lib/sass/compiler/connection.rb

@@ -2,7 +2,7 @@
 
 require 'open3'
 
-require_relative '../../../ext/sass/cli'
+require 'sass/cli'
 
 module Sass
   class Compiler
@@ -12,33 +12,29 @@ module Sass
     class Connection
       def initialize
         @mutex = Mutex.new
-        @stdin, @stdout, @stderr, @wait_thread = begin
-          Open3.popen3(*CLI::COMMAND, '--embedded', chdir: __dir__)
-        rescue Errno::ENOENT
-          require_relative '../elf'
+        @stdin, @stdout, @stderr, @wait_thread = Open3.popen3(*CLI::COMMAND, '--embedded', chdir: __dir__)
 
-          raise if ELF::INTERPRETER.nil?
+        @stdin.binmode
 
-          Open3.popen3(ELF::INTERPRETER, *CLI::COMMAND, '--embedded', chdir: __dir__)
-        end
+        # # https://dart.dev/tools/dart-devtools
+        # if %w[dart dartvm].include?(File.basename(CLI::COMMAND.first, '.exe')) &&
+        #    %w[--enable-vm-service --observe].intersect?(CLI::COMMAND.map { |argument| argument.partition('=').first })
+        #   Kernel.warn(@stdout.readline, uplevel: 0)
+        #   Kernel.warn(@stdout.readline, uplevel: 0)
+        # end
 
-        @stdin.binmode
+        @stdout.binmode
+
+        @wait_thread.name = "sass-embedded-process-waiter-#{id}"
+      end
 
-        @wait_thread.name = "sass-embedded-process-waiter-#{@wait_thread.pid}"
+      def id
+        @wait_thread.pid
       end
 
       def listen(dispatcher)
         Thread.new do
-          Thread.current.name = "sass-embedded-process-stdout-poller-#{@wait_thread.pid}"
-
-          # # https://dart.dev/tools/dart-devtools
-          # if 'dart' == File.basename(CLI::COMMAND.first, '.exe') && CLI::COMMAND.include?('--observe')
-          #   Kernel.warn(@stdout.readline, uplevel: 0)
-          #   Kernel.warn(@stdout.readline, uplevel: 0)
-          # end
-
-          @stdout.binmode
-
+          Thread.current.name = "sass-embedded-process-stdout-poller-#{id}"
           loop do
             length = Varint.read(@stdout)
             id = Varint.read(@stdout)
@@ -53,7 +49,7 @@ module Sass
         end
 
         Thread.new do
-          Thread.current.name = "sass-embedded-process-stderr-poller-#{@wait_thread.pid}"
+          Thread.current.name = "sass-embedded-process-stderr-poller-#{id}"
           loop do
             Kernel.warn(@stderr.readline, uplevel: 0)
           end

data/lib/sass/compiler/dispatcher.rb

@@ -6,13 +6,33 @@ module Sass
     #
     # It dispatches messages between multiple instances of {Host} and a single {Connection} to the compiler.
     class Dispatcher
-      def initialize
+      def initialize(idle_timeout: 0)
         @id = 1
         @observers = {}.compare_by_identity
         @mutex = Mutex.new
         @connection = Connection.new
         @connection.listen(self)
         ForkTracker.add(self)
+
+        return unless idle_timeout.positive?
+
+        @last_accessed_time = current_time
+        Thread.new do
+          Thread.current.name = "sass-embedded-connection-reaper-#{@connection.id}"
+          duration = idle_timeout
+          loop do
+            sleep(duration.negative? ? idle_timeout : duration)
+            break if @mutex.synchronize do
+              raise Errno::EBUSY if _closed?
+
+              duration = idle_timeout - (current_time - @last_accessed_time)
+              duration.negative? && _idle? && _close
+            end
+          end
+          close
+        rescue Errno::EBUSY
+          # do nothing
+        end
       end
 
       def subscribe(observer)
@@ -94,6 +114,10 @@ module Sass
 
       private
 
+      def current_time
+        Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      end
+
       def _close
         @id = 0xffffffff
       end
@@ -103,6 +127,8 @@ module Sass
       end
 
       def _idle
+        @last_accessed_time = current_time if defined?(@last_accessed_time)
+
         @id = 1
       end
 

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

@@ -7,13 +7,13 @@ module Sass
       #
       # It stores sass custom functions and handles function calls.
       class FunctionRegistry
-        attr_reader :global_functions
+        attr_reader :compile_context, :global_functions
 
         def initialize(functions, alert_color:)
-          functions = functions.transform_keys(&:to_s)
-
-          @global_functions = functions.keys
+          @compile_context = Object.new
+          @global_functions = functions.keys.map!(&:to_s)
           @functions_by_name = functions.transform_keys do |signature|
+            signature = signature.to_s
             index = signature.index('(')
             if index
               signature.slice(0, index)
@@ -57,8 +57,8 @@ module Sass
 
           success = protofier.to_proto(function.call(arguments))
           accessed_argument_lists = arguments.filter_map do |argument|
-            if argument.is_a?(Sass::Value::ArgumentList) && argument.instance_eval { @keywords_accessed }
-              argument.instance_eval { @id }
+            if argument.is_a?(Sass::Value::ArgumentList) && argument.instance_variable_get(:@keywords_accessed)
+              argument.instance_variable_get(:@id)
             end
           end
 

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

@@ -25,15 +25,21 @@ module Sass
           @highlight = alert_color
         end
 
+        IMPORTER_ATTRS = %i[non_canonical_scheme].freeze
+
+        IMPORTER_METHODS = %i[canonicalize load find_file_url].freeze
+
+        private_constant :IMPORTER_ATTRS, :IMPORTER_METHODS
+
         def register(importer)
           if importer.is_a?(Sass::NodePackageImporter)
             EmbeddedProtocol::InboundMessage::CompileRequest::Importer.new(
               node_package_importer: EmbeddedProtocol::NodePackageImporter.new(
-                entry_point_directory: importer.instance_eval { @entry_point_directory }
+                entry_point_directory: importer.instance_variable_get(:@entry_point_directory)
               )
             )
           else
-            importer = Structifier.to_struct(importer, :canonicalize, :load, :non_canonical_scheme, :find_file_url)
+            importer = Struct.new(importer, attrs: IMPORTER_ATTRS, methods: IMPORTER_METHODS) if importer.is_a?(::Hash)
 
             is_importer = importer.respond_to?(:canonicalize) && importer.respond_to?(:load)
             is_file_importer = importer.respond_to?(:find_file_url)
@@ -48,12 +54,7 @@ module Sass
               EmbeddedProtocol::InboundMessage::CompileRequest::Importer.new(
                 importer_id: id,
                 non_canonical_scheme: if importer.respond_to?(:non_canonical_scheme)
-                                        non_canonical_scheme = importer.non_canonical_scheme
-                                        if non_canonical_scheme.is_a?(String)
-                                          [non_canonical_scheme]
-                                        else
-                                          non_canonical_scheme || []
-                                        end
+                                        Array(importer.non_canonical_scheme)
                                       else
                                         []
                                       end
@@ -75,7 +76,7 @@ module Sass
           EmbeddedProtocol::InboundMessage::CanonicalizeResponse.new(
             id: canonicalize_request.id,
             url:,
-            containing_url_unused: canonicalize_context.instance_eval { @containing_url_unused }
+            containing_url_unused: canonicalize_context.instance_variable_get(:@containing_url_unused)
           )
         rescue StandardError => e
           EmbeddedProtocol::InboundMessage::CanonicalizeResponse.new(
@@ -84,9 +85,14 @@ module Sass
           )
         end
 
+        IMPORTER_RESULT_ATTRS = %i[contents syntax source_map_url].freeze
+
+        private_constant :IMPORTER_RESULT_ATTRS
+
         def import(import_request)
           importer = @importers_by_id[import_request.importer_id]
-          importer_result = Structifier.to_struct importer.load(import_request.url), :contents, :syntax, :source_map_url
+          importer_result = importer.load(import_request.url)
+          importer_result = Struct.new(importer_result, attrs: IMPORTER_RESULT_ATTRS) if importer_result.is_a?(::Hash)
 
           EmbeddedProtocol::InboundMessage::ImportResponse.new(
             id: import_request.id,
@@ -112,7 +118,7 @@ module Sass
           EmbeddedProtocol::InboundMessage::FileImportResponse.new(
             id: file_import_request.id,
             file_url:,
-            containing_url_unused: canonicalize_context.instance_eval { @containing_url_unused }
+            containing_url_unused: canonicalize_context.instance_variable_get(:@containing_url_unused)
           )
         rescue StandardError => e
           EmbeddedProtocol::InboundMessage::FileImportResponse.new(

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

@@ -7,39 +7,36 @@ module Sass
       #
       # It stores logger and handles log events.
       class LoggerRegistry
-        def initialize(logger)
-          logger = Structifier.to_struct(logger, :debug, :warn)
+        LOGGER_METHODS = %i[debug warn].freeze
 
-          { debug: DebugContext, warn: WarnContext }.each do |symbol, context_class|
-            next unless logger.respond_to?(symbol)
+        private_constant :LOGGER_METHODS
 
-            define_singleton_method(symbol) do |event|
-              logger.public_send(symbol, event.message, context_class.new(event))
-            end
-          end
+        def initialize(logger)
+          logger = Struct.new(logger, methods: LOGGER_METHODS) if logger.is_a?(::Hash)
+          @logger = logger
+          @logger_respond_to_debug = logger.respond_to?(:debug)
+          @logger_respond_to_warn = logger.respond_to?(:warn)
         end
 
         def log(event)
           case event.type
           when :DEBUG
-            debug(event)
+            if @logger_respond_to_debug
+              @logger.debug(event.message, DebugContext.new(event))
+            else
+              Kernel.warn(event.formatted)
+            end
           when :DEPRECATION_WARNING, :WARNING
-            warn(event)
+            if @logger_respond_to_warn
+              @logger.warn(event.message, WarnContext.new(event))
+            else
+              Kernel.warn(event.formatted)
+            end
           else
             raise ArgumentError, "Unknown LogEvent.type #{event.type}"
           end
         end
 
-        private
-
-        def debug(event)
-          Kernel.warn(event.formatted)
-        end
-
-        def warn(event)
-          Kernel.warn(event.formatted)
-        end
-
         # Contextual information passed to `debug`.
         class DebugContext
           # @return [Logger::SourceSpan, nil]