sass-embedded 0.15.0 → 0.17.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8b1ad905f18295ab48835d21b1e6a9c644a860154b37531eeaae2f50f16f70e9
-  data.tar.gz: 229fe63046318d8ce512683d11e3868e8c70d6b28897badeb74be7757ff63e7e
+  metadata.gz: 6c35a262d552f107bf4a13ed024c5c3bfb46da786ff08f4dd116a73211bc9bba
+  data.tar.gz: a0eb5eb4389b4212a66d265eb762511e616d2c5f51c393d2dc7191853501839f
 SHA512:
-  metadata.gz: 20bc3d260f0ac7bd9473351b7f59a08ccd1de7720afc56c027c83025924b7c986335994a4b257344e8c8435c11b5248de2d1dd512cf5e499d85eeddd1166f260
-  data.tar.gz: 5cd706afea71314dc85b47d58f3d4cb9f7ecc82a0a1ed72fc8afc5f772bd98022a8026b62eb490b7c2d9c74c1045d7edb945736078e5195f8c93f858d3f6cc7f
+  metadata.gz: 2a2b5b0aaa9065d64cf12947c96e129cff83d07e628c61e362f0aa4cf7bbdf02ca479508a3f717eaaac4d1466c45a15efffa18882144e5b951ec0242f286d71f
+  data.tar.gz: b4b2b8991b1640f7c5661aede8b13688cea6feb66d2016b96f9ba19d2bc59fdbd13404d317fa0e86819233c58a2ee22c70a25a60d6982be877b787c8cd27baec

data/ext/sass/extconf.rb

@@ -6,7 +6,6 @@ require 'json'
 require 'mkmf'
 require 'open-uri'
 require_relative '../../lib/sass/embedded/compiler/path'
-require_relative '../../lib/sass/embedded/compiler/requirements'
 
 module Sass
   class Embedded
@@ -123,56 +122,12 @@ module Sass
         raise
       end
 
-      def resolve_tag_name(repo, *requirements, gh_release: true)
-        requirements = Gem::Requirement.create(*requirements)
-
-        satisfied = lambda { |version|
-          Gem::Version.correct?(version) && requirements.satisfied_by?(Gem::Version.new(version))
-        }
-
-        headers = {}
-        headers['Authorization'] = "token #{ENV['GITHUB_TOKEN']}" if ENV['GITHUB_TOKEN']
-
-        begin
-          if gh_release
-            releases_uri = "https://github.com/#{repo}/releases"
-            uri = "#{releases_uri}/latest"
-            tag_name = URI.parse(uri).open do |file|
-              return nil if file.base_uri == releases_uri
-
-              latest = File.basename file.base_uri.to_s
-              latest if satisfied.call latest
-            end
-
-            return tag_name unless tag_name.nil?
-
-            uri = "https://api.github.com/repos/#{repo}/releases?per_page=100"
-            tag_name = URI.parse(uri).open(headers) do |file|
-              JSON.parse(file.read).map { |release| release['tag_name'] }
-            end
-                          .find(satisfied)&.peek
-          else
-            uri = "https://api.github.com/repos/#{repo}/tags?per_page=100"
-            tag_name = URI.parse(uri).open(headers) do |file|
-              JSON.parse(file.read).map { |tag| tag['name'] }
-            end
-                          .find(satisfied)&.peek
-          end
-
-          return tag_name unless tag_name.nil?
-        rescue OpenURI::HTTPError => e
-          warn "WARNING:  Error fetching #{uri}: #{e}"
-        end
-
-        requirements.requirements
-                    .map { |requirement| requirement.last.to_s.gsub('.pre.', '-') }
-                    .find(satisfied)&.peek
-      end
-
       def default_sass_embedded
         repo = 'sass/dart-sass-embedded'
 
-        tag_name = resolve_tag_name(repo, Compiler::REQUIREMENTS)
+        spec = JSON.parse(File.read(File.absolute_path('package.json', __dir__)))
+
+        tag_name = spec['dependencies']['sass-embedded']
 
         os = case Platform::OS
              when 'darwin'

data/ext/sass/package.json

@@ -0,0 +1,5 @@
+{
+  "dependencies": {
+    "sass-embedded": "1.49.8"
+  }
+}

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,85 @@
+# frozen_string_literal: true
+
+module Sass
+  class Embedded
+    class CompileContext
+      # The {FunctionRegistry} for {CompileContext}.
+      class FunctionRegistry
+        attr_reader :global_functions
+
+        def initialize(functions)
+          functions = functions.transform_keys(&:to_s)
+
+          @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|
+            value_protofier.from_proto(argument)
+          end
+
+          success = value_protofier.to_proto(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 value_protofier
+          @value_protofier ||= ValueProtofier.new(self)
+        end
+      end
+
+      private_constant :FunctionRegistry
+    end
+  end
+end

data/lib/sass/embedded/compile_context/importer_registry.rb

@@ -0,0 +1,99 @@
+# 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)
+          importer = Structifier.to_struct(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 = Structifier.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/logger_registry.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Sass
+  class Embedded
+    class CompileContext
+      # The {LoggerRegistry} for {CompileContext}.
+      class LoggerRegistry
+        attr_reader :logger
+
+        def initialize(logger)
+          @logger = Structifier.to_struct(logger)
+        end
+
+        def log(event)
+          case event.type
+          when :DEBUG
+            if logger.respond_to? :debug
+              logger.debug(event.message, span: Protofier.from_proto_source_span(event.span))
+            else
+              warn(event.formatted)
+            end
+          when :DEPRECATION_WARNING
+            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(event.formatted)
+            end
+          when :WARNING
+            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(event.formatted)
+            end
+          end
+        end
+      end
+
+      private_constant :LoggerRegistry
+    end
+  end
+end

data/lib/sass/embedded/compile_context/value_protofier.rb

@@ -0,0 +1,237 @@
+# frozen_string_literal: true
+
+module Sass
+  class Embedded
+    class CompileContext
+      # The {ValueProtofier} between Pure Ruby types and Protobuf Ruby types.
+      class ValueProtofier
+        def initialize(function_registry)
+          @function_registry = function_registry
+        end
+
+        def to_proto(obj)
+          case obj
+          when Sass::Value::String
+            Sass::EmbeddedProtocol::Value.new(
+              string: Sass::EmbeddedProtocol::Value::String.new(
+                text: obj.text,
+                quoted: obj.quoted?
+              )
+            )
+          when Sass::Value::Number
+            Sass::EmbeddedProtocol::Value.new(
+              number: Sass::EmbeddedProtocol::Value::Number.new(
+                value: obj.value.to_f,
+                numerators: obj.numerator_units,
+                denominators: obj.denominator_units
+              )
+            )
+          when Sass::Value::Color
+            if obj.instance_eval { @hue.nil? }
+              Sass::EmbeddedProtocol::Value.new(
+                rgb_color: Sass::EmbeddedProtocol::Value::RgbColor.new(
+                  red: obj.red,
+                  green: obj.green,
+                  blue: obj.blue,
+                  alpha: obj.alpha.to_f
+                )
+              )
+            elsif obj.instance_eval { @saturation.nil? }
+              Sass::EmbeddedProtocol::Value.new(
+                hwb_color: Sass::EmbeddedProtocol::Value::HwbColor.new(
+                  hue: obj.hue.to_f,
+                  whiteness: obj.whiteness.to_f,
+                  blackness: obj.blackness.to_f,
+                  alpha: obj.alpha.to_f
+                )
+              )
+            else
+              Sass::EmbeddedProtocol::Value.new(
+                hsl_color: Sass::EmbeddedProtocol::Value::HslColor.new(
+                  hue: obj.hue.to_f,
+                  saturation: obj.saturation.to_f,
+                  lightness: obj.lightness.to_f,
+                  alpha: obj.alpha.to_f
+                )
+              )
+            end
+          when Sass::Value::ArgumentList
+            Sass::EmbeddedProtocol::Value.new(
+              argument_list: Sass::EmbeddedProtocol::Value::ArgumentList.new(
+                id: obj.instance_eval { @id },
+                contents: obj.contents.map { |element| to_proto(element) },
+                keywords: obj.keywords.transform_values { |value| to_proto(value) },
+                separator: ListSeparator.to_proto(obj.separator)
+              )
+            )
+          when Sass::Value::List
+            Sass::EmbeddedProtocol::Value.new(
+              list: Sass::EmbeddedProtocol::Value::List.new(
+                contents: obj.contents.map { |element| to_proto(element) },
+                separator: ListSeparator.to_proto(obj.separator),
+                has_brackets: obj.bracketed?
+              )
+            )
+          when Sass::Value::Map
+            Sass::EmbeddedProtocol::Value.new(
+              map: Sass::EmbeddedProtocol::Value::Map.new(
+                entries: obj.contents.map do |key, value|
+                  Sass::EmbeddedProtocol::Value::Map::Entry.new(
+                    key: to_proto(key),
+                    value: to_proto(value)
+                  )
+                end
+              )
+            )
+          when Sass::Value::Function
+            if obj.id
+              Sass::EmbeddedProtocol::Value.new(
+                compiler_function: Sass::EmbeddedProtocol::Value::CompilerFunction.new(
+                  id: obj.id
+                )
+              )
+            else
+              Sass::EmbeddedProtocol::Value.new(
+                host_function: Sass::EmbeddedProtocol::Value::HostFunction.new(
+                  id: @function_registry.register(obj.callback),
+                  signature: obj.signature
+                )
+              )
+            end
+          when Sass::Value::Boolean
+            Sass::EmbeddedProtocol::Value.new(
+              singleton: obj.value ? :TRUE : :FALSE
+            )
+          when Sass::Value::Null
+            Sass::EmbeddedProtocol::Value.new(
+              singleton: :NULL
+            )
+          else
+            raise Sass::ScriptError, "Unknown Sass::Value #{obj}"
+          end
+        end
+
+        def from_proto(proto)
+          obj = proto.method(proto.value).call
+          case proto.value
+          when :string
+            Sass::Value::String.new(
+              obj.text,
+              quoted: obj.quoted
+            )
+          when :number
+            Sass::Value::Number.new(
+              obj.value,
+              obj.numerators,
+              obj.denominators
+            )
+          when :rgb_color
+            Sass::Value::Color.new(
+              red: obj.red,
+              green: obj.green,
+              blue: obj.blue,
+              alpha: obj.alpha
+            )
+          when :hsl_color
+            Sass::Value::Color.new(
+              hue: obj.hue,
+              saturation: obj.saturation,
+              lightness: obj.lightness,
+              alpha: obj.alpha
+            )
+          when :hwb_color
+            Sass::Value::Color.new(
+              hue: obj.hue,
+              whiteness: obj.whiteness,
+              blackness: obj.blackness,
+              alpha: obj.alpha
+            )
+          when :argument_list
+            Sass::Value::ArgumentList.new(
+              obj.contents.map do |element|
+                from_proto(element)
+              end,
+              obj.keywords.entries.to_h do |entry|
+                [entry.first, from_proto(entry.last)]
+              end,
+              ListSeparator.from_proto(obj.separator)
+            ).instance_eval do
+              @id = obj.id
+              self
+            end
+          when :list
+            Sass::Value::List.new(
+              obj.contents.map do |element|
+                from_proto(element)
+              end,
+              separator: ListSeparator.from_proto(obj.separator),
+              bracketed: obj.has_brackets
+            )
+          when :map
+            Sass::Value::Map.new(
+              obj.entries.to_h do |entry|
+                [from_proto(entry.key), from_proto(entry.value)]
+              end
+            )
+          when :compiler_function
+            Sass::Value::Function.new(obj.id)
+          when :host_function
+            raise ProtocolError, 'The compiler may not send Value.host_function to host'
+          when :singleton
+            case obj
+            when :TRUE
+              Sass::Value::Boolean::TRUE
+            when :FALSE
+              Sass::Value::Boolean::FALSE
+            when :NULL
+              Sass::Value::Null::NULL
+            else
+              raise Sass::ScriptError, "Unknown Value.singleton #{obj}"
+            end
+          else
+            raise Sass::ScriptError, "Unknown Value.value #{obj}"
+          end
+        end
+
+        # The {ListSeparator} Protofier.
+        module ListSeparator
+          module_function
+
+          def to_proto(separator)
+            case separator
+            when ','
+              :COMMA
+            when ' '
+              :SPACE
+            when '/'
+              :SLASH
+            when nil
+              :UNDECIDED
+            else
+              raise Sass::ScriptError, "Unknown ListSeparator #{separator}"
+            end
+          end
+
+          def from_proto(separator)
+            case separator
+            when :COMMA
+              ','
+            when :SPACE
+              ' '
+            when :SLASH
+              '/'
+            when :UNDECIDED
+              nil
+            else
+              raise Sass::ScriptError, "Unknown ListSeparator #{separator}"
+            end
+          end
+        end
+
+        private_constant :ListSeparator
+      end
+
+      private_constant :ValueProtofier
+    end
+  end
+end