sass-embedded 1.54.7-aarch64-linux-gnu

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

@@ -0,0 +1,241 @@
+# 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.transform_values! do |value|
+                from_proto(value)
+              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

@@ -0,0 +1,141 @@
+# 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:,
+                          charset:,
+                          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),
+              charset: charset,
+              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

@@ -0,0 +1,78 @@
+# 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

@@ -0,0 +1,36 @@
+# 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/embedded/varint.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Sass
+  class Embedded
+    # The {Varint} module.
+    #
+    # It reads and writes varints.
+    module Varint
+      module_function
+
+      def read(readable)
+        value = bits = 0
+        loop do
+          byte = readable.readbyte
+          value |= (byte & 0x7f) << bits
+          bits += 7
+          break if byte < 0x80
+        end
+        value
+      end
+
+      def write(writeable, value)
+        bytes = []
+        until value < 0x80
+          bytes << (0x80 | (value & 0x7f))
+          value >>= 7
+        end
+        bytes << value
+        writeable.write bytes.pack('C*')
+      end
+    end
+
+    private_constant :Varint
+  end
+end

data/lib/sass/embedded/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Sass
+  class Embedded
+    VERSION = '1.54.7'
+  end
+end