sass-embedded 1.6.2 → 1.83.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f4302072559a2d7fe8548932c6d860e5acc4a5270c2f2a7c429166cfc7c838ea
-  data.tar.gz: 1a489d71a7ea6c7ce3d7acd1e40f0546d01df683ba6dff52409f6f552a97d8d2
+  metadata.gz: e195e5414c096b69ed749c06fa18abceb7183b9210589eac6ecbe4567e6ca062
+  data.tar.gz: 7db43c7cde6beac01612d5c0cb06e08ed7e3df66054319a6f327a0e3ce8de608
 SHA512:
-  metadata.gz: 2a632cf28ec8df7a914139acd1ba4ba790d142e8816b726c98f3f96a77b2137e9719de4959f70bd723ff348797bab2513feebf278b8c6946b91b69394ff3ce12
-  data.tar.gz: 4ee90b0c45ce7d44789fe689390cdaf70c1e93a840d48ab8ce90eb0e750c91c8244447f04442f8354ccebbc5bfe8f91abcc1e86cd0623ad43ce2cd215e9757b2
+  metadata.gz: 60933b74969f9fc1237b22531bf0f46690564f0556bfbfe26519402970e45c68e1fbd8be03217206ea7b1f833c8563b65078b3d44e28743375bd2798c619c049
+  data.tar.gz: bcc7c53bf5452b3130d119fe0950450d329522c48cafabef5aa1aecb8732e232c5975739a161445fe0a3aa396120b0b1764fbba72a6518f644b5a40efa7ba801

data/README.md

@@ -1,9 +1,9 @@
 # Embedded Sass Host for Ruby
 
-[![build](https://github.com/ntkme/sass-embedded-host-ruby/actions/workflows/build.yml/badge.svg)](https://github.com/ntkme/sass-embedded-host-ruby/actions/workflows/build.yml)
+[![build](https://github.com/sass-contrib/sass-embedded-host-ruby/actions/workflows/build.yml/badge.svg)](https://github.com/sass-contrib/sass-embedded-host-ruby/actions/workflows/build.yml)
 [![gem](https://badge.fury.io/rb/sass-embedded.svg)](https://rubygems.org/gems/sass-embedded)
 
-This is a Ruby library that implements the host side of the [Embedded Sass protocol](https://github.com/sass/sass-embedded-protocol).
+This is a Ruby library that implements the host side of the [Embedded Sass protocol](https://github.com/sass/sass/blob/HEAD/spec/embedded-protocol.md).
 
 It exposes a Ruby API for Sass that's backed by a native [Dart Sass](https://sass-lang.com/dart-sass) executable.
 
@@ -24,6 +24,9 @@ require 'sass-embedded'
 
 result = Sass.compile('style.scss')
 puts result.css
+
+compressed = Sass.compile('style.scss', style: :compressed)
+puts compressed.css
 ```
 
 - `Sass.compile_string` takes a string that represents the contents of a Sass file and return the result of compiling that file to CSS.
@@ -33,9 +36,12 @@ require 'sass-embedded'
 
 result = Sass.compile_string('h1 { font-size: 40px; }')
 puts result.css
+
+compressed = Sass.compile_string('h1 { font-size: 40px; }', style: :compressed)
+puts compressed.css
 ```
 
-See [rubydoc.info/gems/sass-embedded](https://rubydoc.info/gems/sass-embedded) for full API documentation.
+See [rubydoc.info/gems/sass-embedded/Sass](https://rubydoc.info/gems/sass-embedded/Sass) for full API documentation.
 
 ---
 

data/exe/sass

@@ -0,0 +1,13 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require_relative '../ext/sass/cli'
+
+module Sass
+  # The `sass` command line interface
+  module CLI
+    Kernel.exec(*COMMAND, *ARGV)
+  end
+
+  private_constant :CLI
+end

data/ext/sass/Rakefile

@@ -4,44 +4,154 @@ require 'rake/clean'
 
 task default: %i[install clean]
 
-task install: %w[sass_embedded embedded.rb embedded_sass_pb.rb]
-
-CLEAN.include %w[protoc.exe *.proto *.tar.gz *.zip]
+task install: %w[cli.rb] do
+  Rake::Task['embedded_sass_pb.rb'].invoke unless File.exist?('embedded_sass_pb.rb')
+end
 
-CLOBBER.include %w[sass_embedded embedded.rb embedded_sass_pb.rb]
+CLEAN.include %w[
+  protoc.exe
+  ruby
+  *.proto
+  *.tar.gz
+  *.zip
+]
+
+CLOBBER.include %w[
+  dart-sass
+  cli.rb
+  embedded_sass_pb.rb
+  node_modules
+  bun.lockb
+  package-lock.json
+  pnpm-lock.yaml
+  yarn.lock
+]
 
 file 'protoc.exe' do |t|
-  fetch(ENV.fetch('PROTOC_BIN') { Configuration.default_protoc }, t.name)
+  fetch(SassConfig.protoc, t.name)
+  chmod 'a+x', t.name
+rescue NotImplementedError
+  File.write(t.name, <<~PROTOC_EXE)
+    #!#{RbConfig.ruby}
+    # frozen_string_literal: true
+    Kernel.exec('protoc', *ARGV)
+  PROTOC_EXE
   chmod 'a+x', t.name
 end
 
-file 'sass_embedded' do |t|
-  archive = fetch(ENV.fetch(t.name.upcase) { Configuration.default_sass_embedded })
+file 'dart-sass/sass' do |t|
+  gem_install 'sass-embedded', SassConfig.gem_version, SassConfig.gem_platform do |dir|
+    mv File.absolute_path("ext/sass/#{t.name}", dir), t.name
+  end
+rescue StandardError
+  archive = fetch(SassConfig.dart_sass)
   unarchive archive
   rm archive
 end
 
-file 'embedded.rb' => %w[sass_embedded] do |t|
-  path = 'sass_embedded/dart-sass-embedded'
-  path = "#{path}#{['.exe', '.bat'].find { |ext| File.exist? "#{path}#{ext}" }}" if Gem.win_platform?
+file 'node_modules/sass' do
+  sh 'npm', 'install'
+rescue StandardError
+  begin
+    sh 'yarn', 'install'
+  rescue StandardError
+    begin
+      sh 'pnpm', 'install'
+    rescue StandardError
+      sh 'bun', 'install'
+    end
+  end
+end
 
-  raise "#{path} not found" unless File.exist? path
+task 'dart-sass' do
+  Rake::Task['dart-sass/sass'].invoke
+rescue NotImplementedError
+  Rake::Task['node_modules/sass'].invoke
+end
 
-  File.write(t.name, <<~EMBEDDED_RB)
-    # frozen_string_literal: true
+file 'cli.rb' => %w[dart-sass] do |t|
+  require_relative '../../lib/sass/elf'
+
+  begin
+    exe = 'dart-sass/sass'
+    exe = "#{exe}#{['', '.bat', '.exe'].find { |ext| File.exist?("#{exe}#{ext}") }}"
+
+    raise Errno::ENOENT, exe unless File.exist?(exe)
+
+    runtime = 'dart-sass/src/dart'
+    runtime = "#{runtime}#{['', '.exe'].find { |ext| File.exist?("#{runtime}#{ext}") }}"
+    snapshot = 'dart-sass/src/sass.snapshot'
 
-    module Sass
-      class Embedded
-        class Compiler
-          PATH = File.absolute_path('#{path}', __dir__)
+    command = if File.exist?(runtime) && File.exist?(snapshot)
+                [runtime, snapshot]
+              else
+                [exe]
+              end
+
+    interpreter = File.open(command[0], 'rb') do |file|
+      Sass.const_get(:ELF).new(file).interpreter
+    rescue ArgumentError
+      nil
+    end
+
+    command_source = command.map do |argument|
+      "File.absolute_path('#{argument}', __dir__).freeze"
+    end.join(',
+      ')
+  rescue Errno::ENOENT
+    package = 'node_modules/sass'
+
+    script = File.join(package, SassConfig.package_json(package)['bin']['sass'])
+
+    interpreter = nil
+
+    command_source = [
+      "'node'",
+      "File.absolute_path('#{script}', __dir__).freeze"
+    ].join(',
+      ')
+  end
+
+  if interpreter.nil?
+    File.write(t.name, <<~CLI_RB)
+      # frozen_string_literal: true
+
+      module Sass
+        module CLI
+          COMMAND = [
+            #{command_source}
+          ].freeze
         end
+
+        private_constant :CLI
       end
-    end
-  EMBEDDED_RB
+    CLI_RB
+  else
+    File.write(t.name, <<~CLI_RB)
+      # frozen_string_literal: true
+
+      require_relative '../../lib/sass/elf'
+
+      module Sass
+        module CLI
+          INTERPRETER = '#{interpreter}'
+
+          INTERPRETER_SUFFIX = '/#{File.basename(interpreter)}'
+
+          COMMAND = [
+            *(ELF::INTERPRETER if ELF::INTERPRETER != INTERPRETER && ELF::INTERPRETER&.end_with?(INTERPRETER_SUFFIX)),
+            #{command_source}
+          ].freeze
+        end
+
+        private_constant :CLI
+      end
+    CLI_RB
+  end
 end
 
-file 'embedded_sass.proto' => %w[embedded.rb] do |t|
-  fetch(ENV.fetch('SASS_EMBEDDED_PROTOCOL') { Configuration.default_sass_embedded_protocol }, t.name)
+file 'embedded_sass.proto' => %w[cli.rb] do |t|
+  fetch(SassConfig.embedded_sass_protocol, t.name)
 end
 
 rule '_pb.rb' => %w[.proto protoc.exe] do |t|
@@ -51,14 +161,59 @@ end
 # This is a FileUtils extension that defines several additional commands to be
 # added to the FileUtils utility functions.
 module FileUtils
+  # PowerShell quirks:
+  # - `powershell -Command -`:
+  #     Arguments must be part of command, thus cannot pass arguments safely without escaping.
+  # - `powershell -Command <script-block> [-args <arg-array>]`:
+  #     This only works when invoking powershell subshell in powershell.
+  # - `powershell -Command <string> [<CommandParameters>]`:
+  #     CommandParameters are joined with command and then parsed, thus cannot pass arguments safely without escaping.
+  # - `powershell -File -`:
+  #     Arguments must be part of file, thus cannot pass arguments safely without escaping.
+  # - `powershell -File <filePath> <args>`:
+  #     This is the only way to pass arguments safely without escaping.
+  def powershell(file, *args)
+    sh 'powershell', '-NoLogo', '-NoProfile', '-NonInteractive', '-ExecutionPolicy', 'Bypass', '-File', file, *args
+  end
+
+  def junzip(archive, dest = '.')
+    require 'java'
+
+    Rake.rake_output_message "Archive:  #{archive}" if Rake::FileUtilsExt.verbose_flag
+
+    current_directory = java.nio.file.Paths.get(org.jruby.Ruby.getGlobalRuntime.getCurrentDirectory)
+    zip_file = java.util.zip.ZipFile.new(current_directory.resolve(archive).toFile)
+    dest_path = current_directory.resolve(dest).normalize
+    entries = zip_file.entries
+    while entries.hasMoreElements
+      entry = entries.nextElement
+      name = entry.getName
+      path = dest_path.resolve(name).normalize
+      raise SecurityError unless path.startsWith(dest_path)
+
+      Rake.rake_output_message "  inflating: #{name}" if Rake::FileUtilsExt.verbose_flag
+
+      if entry.isDirectory
+        java.nio.file.Files.createDirectories(path)
+      else
+        java.nio.file.Files.createDirectories(path.getParent)
+        java.nio.file.Files.copy(zip_file.getInputStream(entry), path)
+      end
+    end
+  ensure
+    zip_file&.close
+  end
+
   def unarchive(archive, dest = '.')
     case archive.downcase
     when ->(name) { name.include?('.tar.') || name.end_with?('.tar') }
       mkdir_p dest
-      sh 'tar', '-vxC', dest, '-f', archive
+      sh 'tar', '-vxC', dest, '-f', archive, '--no-same-owner', '--no-same-permissions'
     when ->(name) { name.end_with?('.zip') }
-      if Gem.win_platform?
-        sh 'cscript', 'unzip.vbs', '//B', '//Nologo', archive, dest
+      if RUBY_PLATFORM == 'java'
+        junzip archive, dest
+      elsif Gem.win_platform?
+        powershell 'expand-archive.ps1', '-Force', '-LiteralPath', archive, '-DestinationPath', dest
       else
         sh 'unzip', '-od', dest, archive
       end
@@ -70,58 +225,95 @@ module FileUtils
   def fetch(source_uri, dest_path = nil)
     require 'rubygems/remote_fetcher'
 
-    unless source_uri.is_a?(URI::Generic)
+    source_uri = "/#{source_uri}" if !source_uri.start_with?('/') && File.absolute_path?(source_uri)
+
+    source_uri = begin
+      Gem::Uri.parse!(source_uri)
+    rescue NoMethodError
       begin
-        source_uri = URI.parse(source_uri)
+        URI.parse(source_uri)
       rescue StandardError
-        source_uri = URI.parse(URI::DEFAULT_PARSER.escape(source_uri.to_s))
+        URI.parse(URI::DEFAULT_PARSER.escape(source_uri.to_s))
       end
     end
 
     scheme = source_uri.scheme
-    source_path = URI::DEFAULT_PARSER.unescape(source_uri.path || source_uri.opaque)
-
-    if Gem.win_platform? && scheme =~ /^[a-z]$/i && !source_path.include?(':')
-      source_path = "#{scheme}:#{source_path}"
-      scheme = nil
-    end
+    source_path = begin
+      Gem::URI::DEFAULT_PARSER
+    rescue NameError
+      URI::DEFAULT_PARSER
+    end.unescape(source_uri.path)
 
     dest_path = File.basename(source_path) if dest_path.nil?
 
-    case scheme
-    when nil, 'file'
-      if Gem.win_platform? && source_path[0].chr == '/' && source_path[1].chr =~ /[a-z]/i && source_path[2].chr == ':'
-        source_path = source_path[1..]
-      end
-      cp source_path, dest_path
-    else
-      fetcher = Gem::RemoteFetcher.fetcher
-      symbol = "fetch_#{scheme}".to_sym
-      raise ArgumentError, "Unsupported URI scheme #{scheme}" unless fetcher.respond_to?(symbol)
+    fetcher = Gem::RemoteFetcher.fetcher
+    symbol = :"fetch_#{scheme.nil? ? 'file' : scheme}"
+    raise ArgumentError, "Unsupported URI scheme #{scheme}" unless fetcher.respond_to?(symbol)
 
-      if Rake::FileUtilsExt.verbose_flag
-        redacted_uri = Gem::RemoteFetcher::FetchError.new('', source_uri).uri
-        Rake.rake_output_message "fetch #{redacted_uri}"
-      end
+    Rake.rake_output_message "fetch #{Gem::Uri.new(source_uri).redacted}" if Rake::FileUtilsExt.verbose_flag
 
-      unless Rake::FileUtilsExt.nowrite_flag
-        data = fetcher.public_send(symbol, source_uri)
-        Gem.write_binary(dest_path, data)
-      end
+    unless Rake::FileUtilsExt.nowrite_flag
+      data = fetcher.public_send(symbol, source_uri)
+      Gem.write_binary(dest_path, data)
     end
 
     dest_path
   end
+
+  def gem_install(name, version, platform)
+    require 'rubygems/remote_fetcher'
+
+    install_dir = File.absolute_path('ruby')
+
+    if Rake::FileUtilsExt.verbose_flag
+      Rake.rake_output_message [
+        'gem', 'install',
+        '--force',
+        '--install-dir', install_dir,
+        '--no-document', '--ignore-dependencies',
+        '--platform', platform,
+        '--version', version,
+        'sass-embedded'
+      ].join(' ')
+    end
+
+    dependency = Gem::Dependency.new(name, version)
+
+    dependency_request = Gem::Resolver::DependencyRequest.new(dependency, nil)
+
+    resolver_spec = Gem::Resolver::BestSet.new.find_all(dependency_request).find do |s|
+      s.platform == platform
+    end
+
+    raise Gem::UnsatisfiableDependencyError, dependency_request if resolver_spec.nil?
+
+    options = { force: true, install_dir: }
+    if Rake::FileUtilsExt.nowrite_flag
+      installer = Gem::Installer.for_spec(resolver_spec.spec, options)
+    else
+      path = resolver_spec.download(options)
+      installer = Gem::Installer.at(path, options)
+      installer.install
+    end
+
+    yield installer.dir
+  ensure
+    rm_rf install_dir unless Rake::FileUtilsExt.nowrite_flag
+  end
 end
 
-# The {Configuration} module.
-module Configuration
+# The {SassConfig} module.
+module SassConfig
   module Platform
     OS = case RbConfig::CONFIG['host_os'].downcase
          when /darwin/
            'darwin'
+         when /linux-android/
+           'linux-android'
          when /linux-musl/
            'linux-musl'
+         when /linux-uclibc/
+           'linux-uclibc'
          when /linux/
            'linux'
          when *Gem::WIN_PATTERNS
@@ -134,43 +326,53 @@ module Configuration
           when /amd64|x86_64|x64/
             'x86_64'
           when /i\d86|x86|i86pc/
-            'i386'
+            'x86'
           when /arm64|aarch64/
             'aarch64'
           when /arm/
-            # Ruby before 3.0 reports "arm" instead of "arm64" as host_cpu on darwin
-            OS == 'darwin' ? 'aarch64' : 'arm'
+            'arm'
           when /ppc64le|powerpc64le/
             'powerpc64le'
-          when /s390x/
-            's390x'
           else
             RbConfig::CONFIG['host_cpu']
           end
 
-    ARCH = "#{CPU}-#{OS}"
+    ARCH = "#{CPU}-#{OS}".freeze
   end
 
   private_constant :Platform
 
   module_function
 
-  def default_sass_embedded
+  def package_json(path = '.')
     require 'json'
 
-    repo = 'https://github.com/sass/dart-sass-embedded'
+    JSON.parse(File.read(File.absolute_path('package.json', path)))
+  end
+
+  def dart_sass_version
+    package_json['dependencies']['sass']
+  end
+
+  def dart_sass
+    repo = 'https://github.com/sass/dart-sass'
 
-    spec = JSON.parse(File.read(File.absolute_path('package.json', __dir__)))
+    tag_name = dart_sass_version
 
-    tag_name = spec['dependencies']['sass-embedded']
+    message = "dart-sass for #{Platform::ARCH} not available at #{repo}/releases/tag/#{tag_name}"
 
-    message = "sass_embedded 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
@@ -178,32 +380,42 @@ module Configuration
          end
 
     cpu = case Platform::CPU
-          when 'i386'
+          when 'x86'
             'ia32'
           when 'x86_64'
             'x64'
           when 'aarch64'
             'arm64'
+          when 'arm'
+            'arm'
+          when 'riscv64'
+            'riscv64'
           else
             raise NotImplementedError, message
           end
 
-    ext = Gem.win_platform? ? 'zip' : 'tar.gz'
+    ext = Platform::OS == 'windows' ? 'zip' : 'tar.gz'
 
-    "#{repo}/releases/download/#{tag_name}/sass_embedded-#{tag_name}-#{os}-#{cpu}.#{ext}"
+    "#{repo}/releases/download/#{tag_name}/dart-sass-#{tag_name}-#{os}-#{cpu}#{env}.#{ext}"
   end
 
-  def default_protoc
+  def protoc
+    require 'rubygems/remote_fetcher'
+
     repo = 'https://repo.maven.apache.org/maven2/com/google/protobuf/protoc'
 
-    version = Gem::Dependency.new('google-protobuf').to_spec.version
+    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'
+         when 'linux', 'linux-android', 'linux-musl', 'linux-uclibc'
            'linux'
          when 'windows'
            'windows'
@@ -212,7 +424,7 @@ module Configuration
          end
 
     cpu = case Platform::CPU
-          when 'i386'
+          when 'x86'
             'x86_32'
           when 'x86_64'
             'x86_64'
@@ -226,20 +438,84 @@ module Configuration
             raise NotImplementedError, message
           end
 
-    "#{repo}/#{version}/protoc-#{version}-#{os}-#{cpu}.exe"
+    uri = "#{repo}/#{version}/protoc-#{version}-#{os}-#{cpu}.exe"
+
+    Gem::RemoteFetcher.fetcher.fetch_https(Gem::Uri.new("#{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"
+
+      Gem::RemoteFetcher.fetcher.fetch_https(Gem::Uri.new("#{uri}.sha1"))
+
+      return uri
+    rescue Gem::RemoteFetcher::FetchError
+      next
+    end
+
+    raise NotImplementedError, message
   end
 
-  def default_sass_embedded_protocol
+  def embedded_sass_protocol
     require 'json'
     require 'open3'
-    require_relative 'embedded'
 
-    stdout, stderr, status = Open3.capture3(Sass::Embedded::Compiler::PATH, '--version')
+    stdout, stderr, status = Open3.capture3(RbConfig.ruby,
+                                            File.absolute_path('../../exe/sass', __dir__),
+                                            '--embedded',
+                                            '--version')
 
     raise stderr unless status.success?
 
     tag_name = JSON.parse(stdout)['protocolVersion']
 
-    "https://github.com/sass/embedded-protocol/raw/#{tag_name}/embedded_sass.proto"
+    "https://github.com/sass/sass/raw/embedded-protocol-#{tag_name}/spec/embedded_sass.proto"
+  rescue StandardError # TODO: remove after https://github.com/sass/dart-sass/pull/2413
+    'https://github.com/sass/sass/raw/HEAD/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}-#{RbConfig::CONFIG['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