sass-embedded 0.1.1 → 0.2.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 604bb4648958324aedb4a486c281994eb04bc6a2e685e946c07e62ca83ded8ed
-  data.tar.gz: 14730abcf938ee7fe9410a1f0055292c6abf95c95a1a7ab2c6f0d7dc3f2893c8
+  metadata.gz: 5dc860ffde1f3fb6315c2a43972b245841e10e0b0b4a8979a5a4c7528063cd95
+  data.tar.gz: aa76a73fdc4a252b1cd948b90452fa772282408289e99a4e0206c968a5e68898
 SHA512:
-  metadata.gz: 629f7ec2916c32f7821153b47c4c6ebeba09d3995d89273113e9b2ebdb0d477eca9f4ae027fd5144e4b6bdc52c83d2eedc9ca8edcac3d1ea6b79f5f86d528f04
-  data.tar.gz: 2b89c4871759f23a1c3e69d53ca61b1a8e45804435e0d84800beec43aa2bc860c707e3a5d10910e855cbf9d3fece3de658c97739b491b26a1c6aba43dec94fa9
+  metadata.gz: b03c95f66214d6e095fd1e11bbeebe24d56443cf90107661007aef30006502296799c07e4c73974cfa0ca7debc7a807a120c86eb99441363af10f699a9cd0148
+  data.tar.gz: b834e3e9e2a0eb7acdea42e04c1627edc86f2e146c0b96e79331c646b387f8df861fa59d0efeb46d9f3d176b388804d67b63515cc406efb8bb5d7a3c1d4391f6

data/.github/workflows/build.yml

@@ -27,16 +27,13 @@ jobs:
         bundler-cache: true
 
     - name: Download dart-sass-embedded
-      run: bundle exec rake download
+      run: bundle exec rake extconf
       env:
         GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
 
     - name: Test
       run: bundle exec rake
 
-    - name: Build Gem
-      run: rake build
-
     - name: Install Gem
       run: rake install
       env:

data/Gemfile

@@ -1,2 +1,4 @@
+# frozen_string_literal: true
+
 source 'https://rubygems.org'
 gemspec

data/README.md

@@ -1,5 +1,7 @@
 # Embedded Sass Host for Ruby
 
+[![build](https://github.com/ntkme/embedded-host-ruby/actions/workflows/build.yml/badge.svg)](https://github.com/ntkme/embedded-host-ruby/actions/workflows/build.yml)
+
 This is a Ruby library that implements the host side of the [Embedded Sass protocol](https://github.com/sass/sass-embedded-protocol).
 
 It exposes a Ruby API for Sass that's backed by a native [Dart Sass](https://sass-lang.com/dart-sass) executable.

data/Rakefile

@@ -1,14 +1,18 @@
+# frozen_string_literal: true
+
 require 'bundler/gem_tasks'
 
 task default: :test
 
 desc 'Download dart-sass-embedded'
-task :download do
+task :extconf do
+  system('make', '-C', 'ext/sass_embedded', 'distclean')
   require_relative 'ext/sass_embedded/extconf'
+  system('make', '-C', 'ext/sass_embedded', 'install')
 end
 
 desc 'Run all tests'
 task :test do
   $LOAD_PATH.unshift('lib', 'test')
-  Dir.glob('./test/**/*_test.rb') { |f| require f }
+  Dir.glob('./test/**/*_test.rb').sort.each { |f| require f }
 end

data/ext/sass_embedded/Makefile

@@ -1,8 +1,17 @@
+ifeq ($(OS),Windows_NT)
+RM = cmd /c del /f /q /s
+else
+RM = rm -fr
+endif
+
+.PHONY: all
+all:
+
 .PHONY: install
 install:
 ifeq ($(OS),Windows_NT)
-	powershell -command "Get-Item sass_embedded-*.zip | Expand-Archive -DestinationPath (Get-Location) -Force"
-	powershell -command "Get-Item protoc-*.zip | Expand-Archive -DestinationPath protoc -Force"
+	powershell -Command "Get-Item sass_embedded-*.zip | Expand-Archive -DestinationPath . -Force"
+	powershell -Command "Get-Item protoc-*.zip | Expand-Archive -DestinationPath protoc -Force"
 	./protoc/bin/protoc --ruby_out=. embedded_sass.proto
 else
 	tar -vxzf sass_embedded-*.tar.gz
@@ -12,24 +21,8 @@ endif
 
 .PHONY: clean
 clean:
-ifeq ($(OS),Windows_NT)
-	powershell -command "Remove-Item sass_embedded -Recurse -Force -ErrorAction Ignore"
-	powershell -command "Remove-Item protoc -Recurse -Force -ErrorAction Ignore"
-	powershell -command "Remove-Item embedded_sass_pb.rb -Recurse -Force -ErrorAction Ignore"
-else
-	rm -rf sass_embedded
-	rm -rf protoc
-	rm -rf embedded_sass_pb.rb
-endif
+	$(RM) embedded_sass_pb.rb protoc sass_embedded
 
 .PHONY: distclean
 distclean: clean
-ifeq ($(OS),Windows_NT)
-	powershell -command "Remove-Item sass_embedded-*.zip -Force -ErrorAction Ignore"
-	powershell -command "Remove-Item protoc-*.zip -Force -ErrorAction Ignore"
-	powershell -command "Remove-Item embedded_sass.proto -Force -ErrorAction Ignore"
-else
-	rm -rf sass_embedded-*.tar.gz
-	rm -rf protoc-*.zip
-	rm -rf embedded_sass.proto
-endif
+	$(RM) embedded_sass.proto protoc-*.zip sass_embedded-*.tar.gz

data/ext/sass_embedded/extconf.rb

@@ -1,131 +1,129 @@
 #!/usr/bin/env ruby
+# frozen_string_literal: true
 
-require "mkmf"
-require "json"
-require "open-uri"
-require_relative "../../lib/sass/platform"
+require 'json'
+require 'open-uri'
+require_relative '../../lib/sass/platform'
 
-def api url
-  headers = {}
-  headers["Authorization"] = "token #{ENV["GITHUB_TOKEN"]}" if ENV["GITHUB_TOKEN"]
-  URI.open(url, headers) do |file|
-    JSON.parse file.read
-  end
-end
+module Sass
+  class Extconf
 
-def download url
-  URI.open(url) do |source|
-    File.open(File.absolute_path(File.basename(url), __dir__), "wb") do |destination|
-      destination.write source.read
+    def initialize
+      download_sass_embedded
+      download_protoc
+      download_embedded_sass_proto
     end
-  end
-end
 
-def download_sass_embedded
-  repo = "sass/dart-sass-embedded"
-
-  release = api("https://api.github.com/repos/#{repo}/releases")[0]['tag_name']
-
-  os = case Sass::Platform::OS
-       when "darwin"
-         "macos"
-       when "linux"
-         "linux"
-       when "windows"
-         "windows"
-       else
-         raise "Unsupported OS: #{Sass::Platform::OS}"
-       end
-
-  arch = case Sass::Platform::ARCH
-         when "x86_64"
-           "x64"
-         when "i386"
-           "ia32"
-         else
-           raise "Unsupported Arch: #{Sass::Platform::ARCH}"
-         end
-
-  ext = case os
-        when "windows"
-          "zip"
-        else
-          "tar.gz"
-        end
+    private
 
-  url = "https://github.com/#{repo}/releases/download/#{release}/sass_embedded-#{release}-#{os}-#{arch}.#{ext}"
+    def api(url)
+      headers = {}
+      headers['Authorization'] = "token #{ENV['GITHUB_TOKEN']}" if ENV['GITHUB_TOKEN']
+      URI.parse(url).open(headers) do |file|
+        JSON.parse file.read
+      end
+    end
 
-  begin
-    download url
-  rescue
-    raise "Failed to download: #{url}"
-  end
-end
+    def download(url)
+      URI.parse(url).open do |source|
+        File.open(File.absolute_path(File.basename(url), __dir__), 'wb') do |destination|
+          destination.write source.read
+        end
+      end
+    rescue StandardError
+      raise "Failed to download: #{url}"
+    end
 
-def download_protoc
-  repo = "protocolbuffers/protobuf"
-
-  tag = URI.open('https://github.com/protocolbuffers/protobuf/releases/latest') { |file|
-    File.basename file.base_uri.to_s
-  }
-
-  release = tag[1..-1]
-
-  os = case Sass::Platform::OS
-       when "darwin"
-         "osx"
-       when "linux"
-         "linux"
-       when "windows"
-         "win"
-       else
-         raise "Unsupported OS: #{Sass::Platform::OS}"
-       end
-
-  arch = case Sass::Platform::ARCH
-         when "aarch64"
-           "aarch_64"
-         when "sparcv9"
-           "s390"
-         when "i386"
-           "x86_32"
-         when "x86_64"
-           "x86_64"
-         when "powerpc64"
-           "ppcle_64"
-         else
-           raise "Unsupported Arch: #{Sass::Platform::ARCH}"
-         end
-
-  os_arch = case os
-            when "win"
-              os + arch.split('_').last
+    def download_sass_embedded
+      repo = 'sass/dart-sass-embedded'
+
+      release = api("https://api.github.com/repos/#{repo}/releases")[0]['tag_name']
+
+      os = case Sass::Platform::OS
+           when 'darwin'
+             'macos'
+           when 'linux'
+             'linux'
+           when 'windows'
+             'windows'
+           else
+             raise "Unsupported OS: #{Sass::Platform::OS}"
+           end
+
+      arch = case Sass::Platform::ARCH
+             when 'x86_64'
+               'x64'
+             when 'i386'
+               'ia32'
+             else
+               raise "Unsupported Arch: #{Sass::Platform::ARCH}"
+             end
+
+      ext = case os
+            when 'windows'
+              'zip'
             else
-              os + '-' + arch
+              'tar.gz'
             end
 
-  ext = "zip"
+      url = "https://github.com/#{repo}/releases/download/#{release}/sass_embedded-#{release}-#{os}-#{arch}.#{ext}"
+      download url
+    end
 
-  url = "https://github.com/#{repo}/releases/download/#{tag}/protoc-#{release}-#{os_arch}.#{ext}"
+    def download_protoc
+      repo = 'protocolbuffers/protobuf'
+
+      tag = URI.parse("https://github.com/#{repo}/releases/latest").open do |file|
+        File.basename file.base_uri.to_s
+      end
+
+      release = tag[1..-1]
+
+      os = case Sass::Platform::OS
+           when 'darwin'
+             'osx'
+           when 'linux'
+             'linux'
+           when 'windows'
+             'win'
+           else
+             raise "Unsupported OS: #{Sass::Platform::OS}"
+           end
+
+      arch = case Sass::Platform::ARCH
+             when 'aarch64'
+               'aarch_64'
+             when 'sparcv9'
+               's390'
+             when 'i386'
+               'x86_32'
+             when 'x86_64'
+               'x86_64'
+             when 'powerpc64'
+               'ppcle_64'
+             else
+               raise "Unsupported Arch: #{Sass::Platform::ARCH}"
+             end
+
+      os_arch = case os
+                when 'win'
+                  os + arch.split('_').last
+                else
+                  "#{os}-#{arch}"
+                end
+
+      ext = 'zip'
+
+      url = "https://github.com/#{repo}/releases/download/#{tag}/protoc-#{release}-#{os_arch}.#{ext}"
+      download url
+    end
 
-  begin
-    download url
-  rescue
-    raise "Failed to download: #{url}"
-  end
-end
+    def download_embedded_sass_proto
+      url = 'https://raw.githubusercontent.com/sass/embedded-protocol/HEAD/embedded_sass.proto'
+      download url
+    end
 
-def download_embedded_sass_proto
-  url = "https://raw.githubusercontent.com/sass/embedded-protocol/HEAD/embedded_sass.proto"
-  download url
+  end
 end
 
-system("make", "-C", __dir__, "distclean")
-download_sass_embedded
-download_protoc
-download_embedded_sass_proto
-system("make", "-C", __dir__, "install")
-
-File.open(File.absolute_path("sass_embedded.#{RbConfig::CONFIG['DLEXT']}", __dir__), "w") {}
-
-$makefile_created = true
+Sass::Extconf.new

data/lib/sass.rb

@@ -3,9 +3,9 @@
 module Sass
   # 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 `@imported`. This includes path is used by every instance of
-  # {Sass::Embedded::Compiler}. They are lower-precedence than any includes
-  # paths passed in via the `:includes_paths` option.
+  # be `@imported`. 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.
@@ -13,25 +13,30 @@ module Sass
   # (semicolon-separated on Windows).
   #
   # @example
-  #   Sass.include_paths << File.dirname(__FILE__ + '/sass')
+  #   Sass.include_paths << File.dirname(__FILE__) + '/sass'
   # @return [Array<String, Pathname>]
   def self.include_paths
-    @includes_paths ||= if ENV['SASS_PATH']
-                      ENV['SASS_PATH'].split(File::PATH_SEPARATOR)
-                    else
-                      []
-                    end
+    @include_paths ||= if ENV['SASS_PATH']
+                         ENV['SASS_PATH'].split(File::PATH_SEPARATOR)
+                       else
+                         []
+                       end
   end
 
-  def self.render options
-    @compiler ||= Sass::Embedded::Compiler.new
-    @compiler.render options
+  def self.render(options)
+    unless defined? @embedded
+      @embedded = Sass::Embedded.new
+      at_exit do
+        @embedded.close
+      end
+    end
+    @embedded.render options
   end
 end
 
-require_relative "sass/version"
-require_relative "sass/error"
-require_relative "sass/platform"
-require_relative "sass/util"
-require_relative "sass/embedded/transport"
-require_relative "sass/embedded/compiler"
+require_relative 'sass/version'
+require_relative 'sass/error'
+require_relative 'sass/platform'
+require_relative 'sass/util'
+require_relative 'sass/transport'
+require_relative 'sass/embedded'

data/lib/sass/embedded.rb

@@ -0,0 +1,237 @@
+# frozen_string_literal: true
+
+module Sass
+  class Embedded
+    def initialize
+      @transport = Transport.new
+      @id_semaphore = Mutex.new
+      @id = 0
+    end
+
+    def render(options)
+      start = Sass::Util.now
+
+      raise Sass::NotRenderedError, 'Either :data or :file must be set.' if options[:file].nil? && options[:data].nil?
+
+      string = if options[:data]
+                 Sass::EmbeddedProtocol::InboundMessage::CompileRequest::StringInput.new(
+                   source: options[:data],
+                   url: options[:file] ? Sass::Util.file_uri(options[:file]) : 'stdin',
+                   syntax: options[:indented_syntax] == true ? Sass::EmbeddedProtocol::Syntax::INDENTED : Sass::EmbeddedProtocol::Syntax::SCSS
+                 )
+               end
+
+      path = options[:data] ? nil : options[:file]
+
+      style = case options[:output_style]&.to_sym
+              when :expanded, nil
+                Sass::EmbeddedProtocol::OutputStyle::EXPANDED
+              when :compressed
+                Sass::EmbeddedProtocol::OutputStyle::COMPRESSED
+              when :nested, :compact
+                raise Sass::UnsupportedValue, "#{options[:output_style]} is not a supported :output_style"
+              else
+                raise Sass::InvalidStyleError, "#{options[:output_style]} is not a valid :output_style"
+              end
+
+      source_map = options[:source_map].is_a?(String) || (options[:source_map] == true && !options[:out_file].nil?)
+
+      # 1. Loading a file relative to the file in which the @use or @import appeared.
+      # 2. Each custom importer.
+      # 3. Loading a file relative to the current working directory.
+      # 4. Each load path in includePaths
+      # 5. Each load path specified in the SASS_PATH environment variable, which should be semicolon-separated on Windows and colon-separated elsewhere.
+      importers = (if options[:importer]
+                     [
+                       Sass::EmbeddedProtocol::InboundMessage::CompileRequest::Importer.new(importer_id: 0)
+                     ]
+                   else
+                     []
+                   end).concat(
+                     (options[:include_paths] || []).concat(Sass.include_paths)
+                     .map do |include_path|
+                       Sass::EmbeddedProtocol::InboundMessage::CompileRequest::Importer.new(
+                         path: File.absolute_path(include_path)
+                       )
+                     end
+                   )
+
+      signatures = []
+      functions = {}
+      options[:functions]&.each do |signature, function|
+        signatures.push signature
+        functions[signature.to_s.split('(')[0].chomp] = function
+      end
+
+      compilation_id = next_id
+
+      compile_request = Sass::EmbeddedProtocol::InboundMessage::CompileRequest.new(
+        id: compilation_id,
+        string: string,
+        path: path,
+        style: style,
+        source_map: source_map,
+        importers: importers,
+        global_functions: options[:functions] ? signatures : [],
+        alert_color: true,
+        alert_ascii: true
+      )
+
+      response = @transport.send compile_request, compilation_id
+
+      file = options[:file] || 'stdin'
+      canonicalizations = {}
+      imports = {}
+
+      loop do
+        case response
+        when Sass::EmbeddedProtocol::OutboundMessage::CompileResponse
+          break
+        when Sass::EmbeddedProtocol::OutboundMessage::CanonicalizeRequest
+          url = Sass::Util.file_uri(File.absolute_path(response.url, File.dirname(file)))
+
+          if canonicalizations.key? url
+            canonicalizations[url].id = response.id
+          else
+            resolved = nil
+            options[:importer].each do |importer|
+              begin
+                resolved = importer.call response.url, file
+              rescue StandardError => e
+                resolved = e
+              end
+              break if resolved
+            end
+            if resolved.nil?
+              canonicalizations[url] = Sass::EmbeddedProtocol::InboundMessage::CanonicalizeResponse.new(
+                id: response.id,
+                url: url
+              )
+            elsif resolved.is_a? StandardError
+              canonicalizations[url] = Sass::EmbeddedProtocol::InboundMessage::CanonicalizeResponse.new(
+                id: response.id,
+                error: resolved.message
+              )
+            elsif resolved.key? :contents
+              canonicalizations[url] = Sass::EmbeddedProtocol::InboundMessage::CanonicalizeResponse.new(
+                id: response.id,
+                url: url
+              )
+              imports[url] = Sass::EmbeddedProtocol::InboundMessage::ImportResponse.new(
+                id: response.id,
+                success: Sass::EmbeddedProtocol::InboundMessage::ImportResponse::ImportSuccess.new(
+                  contents: resolved[:contents],
+                  syntax: Sass::EmbeddedProtocol::Syntax::SCSS,
+                  source_map_url: nil
+                )
+              )
+            elsif resolved.key? :file
+              canonicalized_url = Sass::Util.file_uri(resolved[:file])
+              canonicalizations[url] = Sass::EmbeddedProtocol::InboundMessage::CanonicalizeResponse.new(
+                id: response.id,
+                url: canonicalized_url
+              )
+              imports[canonicalized_url] = Sass::EmbeddedProtocol::InboundMessage::ImportResponse.new(
+                id: response.id,
+                success: Sass::EmbeddedProtocol::InboundMessage::ImportResponse::ImportSuccess.new(
+                  contents: File.read(resolved[:file]),
+                  syntax: Sass::EmbeddedProtocol::Syntax::SCSS,
+                  source_map_url: nil
+                )
+              )
+            else
+              canonicalizations[url] = Sass::EmbeddedProtocol::InboundMessage::CanonicalizeResponse.new(
+                id: response.id,
+                error: "Unexpected value returned from importer: #{resolved}"
+              )
+            end
+          end
+
+          response = @transport.send canonicalizations[url], compilation_id
+        when Sass::EmbeddedProtocol::OutboundMessage::ImportRequest
+          url = response.url
+
+          if imports.key? url
+            imports[url].id = response.id
+          else
+            imports[url] = Sass::EmbeddedProtocol::InboundMessage::ImportResponse.new(
+              id: response.id,
+              error: "Failed to import: #{url}"
+            )
+          end
+
+          response = @transport.send imports[url], compilation_id
+        when Sass::EmbeddedProtocol::OutboundMessage::FunctionCallRequest
+          begin
+            message = Sass::EmbeddedProtocol::InboundMessage::FunctionCallResponse.new(
+              id: response.id,
+              success: functions[response.name].call(*response.arguments)
+            )
+          rescue StandardError => e
+            message = Sass::EmbeddedProtocol::InboundMessage::FunctionCallResponse.new(
+              id: response.id,
+              error: e.message
+            )
+          end
+
+          response = @transport.send message, compilation_id
+        when Sass::EmbeddedProtocol::ProtocolError
+          raise Sass::ProtocolError, response.message
+        else
+          raise Sass::ProtocolError, "Unexpected packet received: #{response}"
+        end
+      end
+
+      if response.failure
+        raise Sass::CompilationError.new(
+          response.failure.message,
+          response.failure.formatted,
+          response.failure.span ? response.failure.span.url : nil,
+          response.failure.span ? response.failure.span.start.line + 1 : nil,
+          response.failure.span ? response.failure.span.start.column + 1 : nil,
+          1
+        )
+      end
+
+      finish = Sass::Util.now
+
+      {
+        css: response.success.css,
+        map: response.success.source_map,
+        stats: {
+          entry: options[:file] || 'data',
+          start: start,
+          end: finish,
+          duration: finish - start
+        }
+      }
+    end
+
+    def close
+      @transport.close
+      nil
+    end
+
+    private
+
+    def info
+      version_response = @transport.send Sass::EmbeddedProtocol::InboundMessage::VersionRequest.new(
+        id: next_id
+      )
+      {
+        compiler_version: version_response.compiler_version,
+        protocol_version: version_response.protocol_version,
+        implementation_name: version_response.implementation_name,
+        implementation_version: version_response.implementation_version
+      }
+    end
+
+    def next_id
+      @id_semaphore.synchronize do
+        @id += 1
+        @id = 0 if @id == Transport::PROTOCOL_ERROR_ID
+        @id
+      end
+    end
+  end
+end