sass-embedded 0.14.0 → 0.16.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1c998b528ffddfc218f32dbefa09559dbdf519cf8a430f8dc9a58d4cae8a7b2a
-  data.tar.gz: 84bb150040b3e01d68b7673f00ab08041deb98e357cb653a01ca99e40569f553
+  metadata.gz: bc4a584b02baef5fc270ec2ce84d7843c01f3656e64aa0c30e303a1d4c123313
+  data.tar.gz: d2230700daf1964f727ca1e5d5c695244cdb1d304700ad15997526ccb62ad31c
 SHA512:
-  metadata.gz: cb4dd021d2dfd85b652dcf88c523e106c84a8ebcfa8e158c02f5a8b43aa4fc852b506dd39b33cf83766253be59bb084b7612a49165883eca4062c9c17b5f1a25
-  data.tar.gz: d804392b2bc53fccba57c2d68c86f9118ffe80c24c854cea62b462738185634d59af4e41fc8ea86fabe0db120e16133d15bb3f2822ad3064c1c4e7c467796871
+  metadata.gz: 9fc031920618a3bc5b40a5c146b7ef8fc56b9d048b5c481b214425f3e17b72d05651ef1645b29ac08a15c5504d0c48b4f6605e6e5c13224560a9b26d212b13e9
+  data.tar.gz: e2a1e112ab8241f2a5393d01b237d1a9d41dcca7f386fdaa42a287c5a9cd82d4a6ec909775598a4235a373573ff76381df302f07f16861399ecad35734ea9913

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