sass-embedded 1.6.2 → 1.83.1

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

@@ -1,50 +0,0 @@
-# frozen_string_literal: true
-
-module Sass
-  class Embedded
-    class Host
-      # The {LoggerRegistry} class.
-      #
-      # It stores logger and handles log events.
-      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/host/value_protofier.rb

@@ -1,241 +0,0 @@
-# frozen_string_literal: true
-
-module Sass
-  class Embedded
-    class Host
-      # The {ValueProtofier} class.
-      #
-      # It converts 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 { !defined?(@hue) }
-              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 { !defined?(@saturation) }
-              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)
-          oneof = proto.value
-          obj = proto.public_send(oneof)
-          case oneof
-          when :string
-            Sass::Value::String.new(
-              obj.text,
-              quoted: obj.quoted
-            )
-          when :number
-            Sass::Value::Number.new(
-              obj.value, {
-                numerator_units: obj.numerators.to_a,
-                denominator_units: obj.denominators.to_a
-              }
-            )
-          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

data/lib/sass/embedded/host.rb

@@ -1,139 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'host/function_registry'
-require_relative 'host/importer_registry'
-require_relative 'host/logger_registry'
-require_relative 'host/value_protofier'
-
-module Sass
-  class Embedded
-    # The {Host} class.
-    #
-    # It communicates with {Dispatcher} and handles the host logic.
-    class Host
-      def initialize(channel)
-        @channel = channel
-      end
-
-      def id
-        @connection.id
-      end
-
-      def send_message(message)
-        @connection.send_message(message)
-      end
-
-      def compile_request(path:,
-                          source:,
-                          importer:,
-                          load_paths:,
-                          syntax:,
-                          url:,
-                          source_map:,
-                          source_map_include_sources:,
-                          style:,
-                          functions:,
-                          importers:,
-                          alert_ascii:,
-                          alert_color:,
-                          logger:,
-                          quiet_deps:,
-                          verbose:)
-        await do
-          alert_color = $stderr.tty? if alert_color.nil?
-
-          @function_registry = FunctionRegistry.new(functions, alert_color: alert_color)
-          @importer_registry = ImporterRegistry.new(importers, load_paths, alert_color: alert_color)
-          @logger_registry = LoggerRegistry.new(logger)
-
-          send_message EmbeddedProtocol::InboundMessage.new(
-            compile_request: EmbeddedProtocol::InboundMessage::CompileRequest.new(
-              id: id,
-              string: unless source.nil?
-                        EmbeddedProtocol::InboundMessage::CompileRequest::StringInput.new(
-                          source: source,
-                          url: url&.to_s,
-                          syntax: Protofier.to_proto_syntax(syntax),
-                          importer: (@importer_registry.register(importer) unless importer.nil?)
-                        )
-                      end,
-              path: (File.absolute_path(path) unless path.nil?),
-              style: Protofier.to_proto_output_style(style),
-              source_map: source_map,
-              source_map_include_sources: source_map_include_sources,
-              importers: @importer_registry.importers,
-              global_functions: @function_registry.global_functions,
-              alert_ascii: alert_ascii,
-              alert_color: alert_color,
-              quiet_deps: quiet_deps,
-              verbose: verbose
-            )
-          )
-        end
-      end
-
-      def version_request
-        await do
-          send_message EmbeddedProtocol::InboundMessage.new(
-            version_request: EmbeddedProtocol::InboundMessage::VersionRequest.new(
-              id: id
-            )
-          )
-        end
-      end
-
-      def log_event(message)
-        @logger_registry.log(message)
-      end
-
-      def compile_response(message)
-        @async.resolve(message)
-      end
-
-      def version_response(message)
-        @async.resolve(message)
-      end
-
-      def canonicalize_request(message)
-        send_message EmbeddedProtocol::InboundMessage.new(
-          canonicalize_response: @importer_registry.canonicalize(message)
-        )
-      end
-
-      def import_request(message)
-        send_message EmbeddedProtocol::InboundMessage.new(
-          import_response: @importer_registry.import(message)
-        )
-      end
-
-      def file_import_request(message)
-        send_message EmbeddedProtocol::InboundMessage.new(
-          file_import_response: @importer_registry.file_import(message)
-        )
-      end
-
-      def function_call_request(message)
-        send_message EmbeddedProtocol::InboundMessage.new(
-          function_call_response: @function_registry.function_call(message)
-        )
-      end
-
-      def error(message)
-        @async.reject(CompileError.new(message.message, nil, nil, nil))
-      end
-
-      private
-
-      def await
-        @connection = @channel.connect(self)
-        @async = Async.new
-        yield
-        @async.await
-      ensure
-        @connection.disconnect
-      end
-    end
-
-    private_constant :Host
-  end
-end

data/lib/sass/embedded/protofier.rb

@@ -1,78 +0,0 @@
-# frozen_string_literal: true
-
-module Sass
-  class Embedded
-    # The {Protofier} module.
-    #
-    # It converts Pure Ruby types and Protobuf Ruby types.
-    module Protofier
-      module_function
-
-      def from_proto_compile_response(compile_response)
-        oneof = compile_response.result
-        result = compile_response.public_send(oneof)
-        case oneof
-        when :failure
-          raise CompileError.new(
-            result.message,
-            result.formatted,
-            result.stack_trace,
-            from_proto_source_span(result.span)
-          )
-        when :success
-          CompileResult.new(
-            result.css,
-            result.source_map,
-            result.loaded_urls
-          )
-        else
-          raise ArgumentError, "Unknown CompileResponse.result #{result}"
-        end
-      end
-
-      def from_proto_source_span(source_span)
-        return if source_span.nil?
-
-        Logger::SourceSpan.new(from_proto_source_location(source_span.start),
-                               from_proto_source_location(source_span.end),
-                               source_span.text,
-                               source_span.url,
-                               source_span.context)
-      end
-
-      def from_proto_source_location(source_location)
-        return if source_location.nil?
-
-        Logger::SourceLocation.new(source_location.offset,
-                                   source_location.line,
-                                   source_location.column)
-      end
-
-      def to_proto_syntax(syntax)
-        case syntax&.to_sym
-        when :scss
-          EmbeddedProtocol::Syntax::SCSS
-        when :indented
-          EmbeddedProtocol::Syntax::INDENTED
-        when :css
-          EmbeddedProtocol::Syntax::CSS
-        else
-          raise ArgumentError, 'syntax must be one of :scss, :indented, :css'
-        end
-      end
-
-      def to_proto_output_style(style)
-        case style&.to_sym
-        when :expanded
-          EmbeddedProtocol::OutputStyle::EXPANDED
-        when :compressed
-          EmbeddedProtocol::OutputStyle::COMPRESSED
-        else
-          raise ArgumentError, 'style must be one of :expanded, :compressed'
-        end
-      end
-    end
-
-    private_constant :Protofier
-  end
-end

data/lib/sass/embedded/structifier.rb

@@ -1,36 +0,0 @@
-# frozen_string_literal: true
-
-module Sass
-  class Embedded
-    # The {Structifier} module.
-    #
-    # It converts {::Hash} to {Struct}-like objects.
-    module Structifier
-      module_function
-
-      def to_struct(obj)
-        return obj unless obj.is_a? Hash
-
-        struct = Object.new
-        obj.each do |key, value|
-          if value.respond_to? :call
-            struct.define_singleton_method key.to_sym do |*args, **kwargs|
-              if kwargs.empty?
-                value.call(*args)
-              else
-                value.call(*args, **kwargs)
-              end
-            end
-          else
-            struct.define_singleton_method key.to_sym do
-              value
-            end
-          end
-        end
-        struct
-      end
-    end
-
-    private_constant :Structifier
-  end
-end

data/lib/sass/script_error.rb

@@ -1,6 +0,0 @@
-# frozen_string_literal: true
-
-module Sass
-  # An exception thrown by Sass Script.
-  class ScriptError < StandardError; end
-end