sass-embedded 1.74.1-x86_64-cygwin

data/lib/sass/compiler/host.rb

@@ -0,0 +1,226 @@
+# frozen_string_literal: true
+
+require_relative 'host/function_registry'
+require_relative 'host/importer_registry'
+require_relative 'host/logger_registry'
+require_relative 'host/protofier'
+require_relative 'host/structifier'
+
+module Sass
+  class Compiler
+    # The {Host} class.
+    #
+    # It communicates with {Dispatcher} and handles the host logic.
+    class Host
+      def initialize(channel)
+        @channel = channel
+      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:,
+                          fatal_deprecations:,
+                          future_deprecations:,
+                          logger:,
+                          quiet_deps:,
+                          silence_deprecations:,
+                          verbose:)
+        alert_color = Exception.respond_to?(:to_tty?) && Exception.to_tty? if alert_color.nil?
+
+        @function_registry = FunctionRegistry.new(functions, alert_color:)
+        @importer_registry = ImporterRegistry.new(importers, load_paths, alert_color:)
+        @logger_registry = LoggerRegistry.new(logger)
+
+        compile_request = EmbeddedProtocol::InboundMessage::CompileRequest.new(
+          string: unless source.nil?
+                    EmbeddedProtocol::InboundMessage::CompileRequest::StringInput.new(
+                      source: source.to_str,
+                      url: url&.to_s,
+                      syntax: @importer_registry.syntax_to_proto(syntax),
+                      importer: (@importer_registry.register(importer) unless importer.nil?)
+                    )
+                  end,
+          path: (File.absolute_path(path) unless path.nil?),
+          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,
+          charset:,
+          source_map:,
+          source_map_include_sources:,
+          importers: @importer_registry.importers,
+          global_functions: @function_registry.global_functions,
+          alert_ascii:,
+          alert_color:,
+          fatal_deprecation: fatal_deprecations,
+          future_deprecation: future_deprecations,
+          quiet_deps:,
+          silent: logger == Logger.silent,
+          silence_deprecation: silence_deprecations,
+          verbose:
+        )
+
+        compile_response = await do
+          send_message(compile_request:)
+        end
+
+        oneof = compile_response.result
+        result = compile_response.public_send(oneof)
+        case oneof
+        when :failure
+          raise CompileError.new(
+            result.message,
+            result.formatted == '' ? nil : result.formatted,
+            result.stack_trace == '' ? nil : result.stack_trace,
+            result.span.nil? ? nil : Logger::SourceSpan.new(result.span),
+            compile_response.loaded_urls.to_a
+          )
+        when :success
+          CompileResult.new(
+            result.css,
+            result.source_map == '' ? nil : result.source_map,
+            compile_response.loaded_urls.to_a
+          )
+        else
+          raise ArgumentError, "Unknown CompileResponse.result #{result}"
+        end
+      end
+
+      def version_request
+        version_response = await0 do
+          send_message0(version_request: EmbeddedProtocol::InboundMessage::VersionRequest.new(
+            id:
+          ))
+        end
+
+        info = [
+          version_response.implementation_name,
+          version_response.implementation_version,
+          '(Sass Compiler)'
+        ]
+
+        case version_response.implementation_name
+        when 'dart-sass'
+          info << '[Dart]'
+        end
+
+        info
+      end
+
+      def compile_response(message)
+        @result = message
+        @queue.close
+      end
+
+      def version_response(message)
+        @result = message
+        @queue.close
+      end
+
+      def error(message)
+        case message
+        when EmbeddedProtocol::ProtocolError
+          raise Errno::EPROTO, message.message
+        else
+          @error ||= message
+          @queue.close
+        end
+      end
+
+      def log_event(message)
+        @logger_registry.log(message)
+      end
+
+      def canonicalize_request(message)
+        send_message(canonicalize_response: @importer_registry.canonicalize(message))
+      end
+
+      def import_request(message)
+        send_message(import_response: @importer_registry.import(message))
+      end
+
+      def file_import_request(message)
+        send_message(file_import_response: @importer_registry.file_import(message))
+      end
+
+      def function_call_request(message)
+        send_message(function_call_response: @function_registry.function_call(message))
+      end
+
+      def receive_proto(proto)
+        @queue.push(proto)
+      end
+
+      private
+
+      def await0
+        listen do
+          yield
+
+          @queue.pop
+        end
+      end
+
+      def await
+        listen do
+          yield
+
+          while (proto = @queue.pop)
+            outbound_message = EmbeddedProtocol::OutboundMessage.decode(proto)
+            oneof = outbound_message.message
+            message = outbound_message.public_send(oneof)
+            public_send(oneof, message)
+          end
+        rescue Exception => e # rubocop:disable Lint/RescueException
+          @stream.error(e)
+          raise
+        end
+      end
+
+      def listen
+        @queue = Queue.new
+        @stream = @channel.stream(self)
+
+        yield
+
+        raise @error if @error
+
+        @result
+      ensure
+        @stream&.close
+        @queue&.close
+      end
+
+      def id
+        @stream.id
+      end
+
+      def send_message0(...)
+        inbound_message = EmbeddedProtocol::InboundMessage.new(...)
+        @stream.send_proto(0, EmbeddedProtocol::InboundMessage.encode(inbound_message))
+      end
+
+      def send_message(...)
+        inbound_message = EmbeddedProtocol::InboundMessage.new(...)
+        @stream.send_proto(id, EmbeddedProtocol::InboundMessage.encode(inbound_message))
+      end
+    end
+
+    private_constant :Host
+  end
+end

data/lib/sass/compiler/varint.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Sass
+  class Compiler
+    # The {Varint} module.
+    #
+    # It reads and writes varints.
+    module Varint
+      module_function
+
+      def length(value)
+        return 1 if value < 128
+
+        (value.bit_length + 6) / 7
+      end
+
+      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)
+        until value < 0x80
+          writeable << ((value & 0x7f) | 0x80)
+          value >>= 7
+        end
+        writeable << value
+      end
+    end
+
+    private_constant :Varint
+  end
+end

data/lib/sass/compiler.rb

@@ -0,0 +1,212 @@
+# frozen_string_literal: true
+
+require_relative 'canonicalize_context'
+require_relative 'compile_result'
+require_relative 'compiler/channel'
+require_relative 'compiler/connection'
+require_relative 'compiler/dispatcher'
+require_relative 'compiler/host'
+require_relative 'compiler/varint'
+require_relative 'embedded/version'
+require_relative 'embedded_protocol'
+require_relative 'exception'
+require_relative 'fork_tracker'
+require_relative 'logger/silent'
+require_relative 'logger/source_location'
+require_relative 'logger/source_span'
+require_relative 'node_package_importer'
+require_relative 'serializer'
+require_relative 'value'
+
+module Sass
+  # A synchronous {Compiler}.
+  # Each compiler instance exposes the {#compile} and {#compile_string} methods within the lifespan of the compiler.
+  #
+  # @example
+  #   sass = Sass::Compiler.new
+  #   result = sass.compile_string('h1 { font-size: 40px; }')
+  #   result = sass.compile('style.scss')
+  #   sass.close
+  # @see https://sass-lang.com/documentation/js-api/classes/compiler/
+  class Compiler
+    def initialize
+      @channel = Channel.new(Dispatcher)
+    end
+
+    # Compiles the Sass file at +path+ to CSS.
+    # @param path [String]
+    # @param load_paths [Array<String>] Paths in which to look for stylesheets loaded by rules like
+    #   {@use}[https://sass-lang.com/documentation/at-rules/use/] and {@import}[https://sass-lang.com/documentation/at-rules/import/].
+    # @param charset [Boolean] By default, if the CSS document contains non-ASCII characters, Sass adds a +@charset+
+    #   declaration (in expanded output mode) or a byte-order mark (in compressed mode) to indicate its encoding to
+    #   browsers or other consumers. If +charset+ is +false+, these annotations are omitted.
+    # @param source_map [Boolean] Whether or not Sass should generate a source map.
+    # @param source_map_include_sources [Boolean] Whether Sass should include the sources in the generated source map.
+    # @param style [Symbol] The OutputStyle of the compiled CSS.
+    # @param functions [Hash<String, Proc>] Additional built-in Sass functions that are available in all stylesheets.
+    # @param importers [Array<Object>] Custom importers that control how Sass resolves loads from rules like
+    #   {@use}[https://sass-lang.com/documentation/at-rules/use/] and {@import}[https://sass-lang.com/documentation/at-rules/import/].
+    # @param alert_ascii [Boolean] If this is +true+, the compiler will exclusively use ASCII characters in its error
+    #   and warning messages. Otherwise, it may use non-ASCII Unicode characters as well.
+    # @param alert_color [Boolean] If this is +true+, the compiler will use ANSI color escape codes in its error and
+    #   warning messages. If it's +false+, it won't use these. If it's +nil+, the compiler will determine whether or
+    #   not to use colors depending on whether the user is using an interactive terminal.
+    # @param fatal_deprecations [Array<String>] A set of deprecations to treat as fatal.
+    # @param future_deprecations [Array<String>] A set of future deprecations to opt into early.
+    # @param logger [Object] An object to use to handle warnings and/or debug messages from Sass.
+    # @param quiet_deps [Boolean] If this option is set to +true+, Sass won’t print warnings that are caused by
+    #   dependencies. A “dependency” is defined as any file that’s loaded through +load_paths+ or +importer+.
+    #   Stylesheets that are imported relative to the entrypoint are not considered dependencies.
+    # @param silence_deprecations [Array<String>] A set of active deprecations to ignore.
+    # @param verbose [Boolean] By default, Dart Sass will print only five instances of the same deprecation warning per
+    #   compilation to avoid deluging users in console noise. If you set verbose to +true+, it will instead print every
+    #   deprecation warning it encounters.
+    # @return [CompileResult]
+    # @raise [ArgumentError, CompileError]
+    # @see https://sass-lang.com/documentation/js-api/functions/compile/
+    def compile(path,
+                load_paths: [],
+
+                charset: true,
+                source_map: false,
+                source_map_include_sources: false,
+                style: :expanded,
+
+                functions: {},
+                importers: [],
+
+                alert_ascii: false,
+                alert_color: nil,
+                fatal_deprecations: [],
+                future_deprecations: [],
+                logger: nil,
+                quiet_deps: false,
+                silence_deprecations: [],
+                verbose: false)
+      raise ArgumentError, 'path must be set' if path.nil?
+
+      Host.new(@channel).compile_request(
+        path:,
+        source: nil,
+        importer: nil,
+        load_paths:,
+        syntax: nil,
+        url: nil,
+        charset:,
+        source_map:,
+        source_map_include_sources:,
+        style:,
+        functions:,
+        importers:,
+        alert_color:,
+        alert_ascii:,
+        fatal_deprecations:,
+        future_deprecations:,
+        logger:,
+        quiet_deps:,
+        silence_deprecations:,
+        verbose:
+      )
+    end
+
+    # Compiles a stylesheet whose contents is +source+ to CSS.
+    # @param source [String]
+    # @param importer [Object] The importer to use to handle loads that are relative to the entrypoint stylesheet.
+    # @param load_paths [Array<String>] Paths in which to look for stylesheets loaded by rules like
+    #   {@use}[https://sass-lang.com/documentation/at-rules/use/] and {@import}[https://sass-lang.com/documentation/at-rules/import/].
+    # @param syntax [Symbol] The Syntax to use to parse the entrypoint stylesheet.
+    # @param url [String] The canonical URL of the entrypoint stylesheet. If this is passed along with +importer+, it's
+    #   used to resolve relative loads in the entrypoint stylesheet.
+    # @param charset [Boolean] By default, if the CSS document contains non-ASCII characters, Sass adds a +@charset+
+    #   declaration (in expanded output mode) or a byte-order mark (in compressed mode) to indicate its encoding to
+    #   browsers or other consumers. If +charset+ is +false+, these annotations are omitted.
+    # @param source_map [Boolean] Whether or not Sass should generate a source map.
+    # @param source_map_include_sources [Boolean] Whether Sass should include the sources in the generated source map.
+    # @param style [Symbol] The OutputStyle of the compiled CSS.
+    # @param functions [Hash<String, Proc>] Additional built-in Sass functions that are available in all stylesheets.
+    # @param importers [Array<Object>] Custom importers that control how Sass resolves loads from rules like
+    #   {@use}[https://sass-lang.com/documentation/at-rules/use/] and {@import}[https://sass-lang.com/documentation/at-rules/import/].
+    # @param alert_ascii [Boolean] If this is +true+, the compiler will exclusively use ASCII characters in its error
+    #   and warning messages. Otherwise, it may use non-ASCII Unicode characters as well.
+    # @param alert_color [Boolean] If this is +true+, the compiler will use ANSI color escape codes in its error and
+    #   warning messages. If it's +false+, it won't use these. If it's +nil+, the compiler will determine whether or
+    #   not to use colors depending on whether the user is using an interactive terminal.
+    # @param fatal_deprecations [Array<String>] A set of deprecations to treat as fatal.
+    # @param future_deprecations [Array<String>] A set of future deprecations to opt into early.
+    # @param logger [Object] An object to use to handle warnings and/or debug messages from Sass.
+    # @param quiet_deps [Boolean] If this option is set to +true+, Sass won’t print warnings that are caused by
+    #   dependencies. A “dependency” is defined as any file that’s loaded through +load_paths+ or +importer+.
+    #   Stylesheets that are imported relative to the entrypoint are not considered dependencies.
+    # @param silence_deprecations [Array<String>] A set of active deprecations to ignore.
+    # @param verbose [Boolean] By default, Dart Sass will print only five instances of the same deprecation warning per
+    #   compilation to avoid deluging users in console noise. If you set verbose to +true+, it will instead print every
+    #   deprecation warning it encounters.
+    # @return [CompileResult]
+    # @raise [ArgumentError, CompileError]
+    # @see https://sass-lang.com/documentation/js-api/functions/compilestring/
+    def compile_string(source,
+                       importer: nil,
+                       load_paths: [],
+                       syntax: :scss,
+                       url: nil,
+
+                       charset: true,
+                       source_map: false,
+                       source_map_include_sources: false,
+                       style: :expanded,
+
+                       functions: {},
+                       importers: [],
+
+                       alert_ascii: false,
+                       alert_color: nil,
+                       fatal_deprecations: [],
+                       future_deprecations: [],
+                       logger: nil,
+                       quiet_deps: false,
+                       silence_deprecations: [],
+                       verbose: false)
+      raise ArgumentError, 'source must be set' if source.nil?
+
+      Host.new(@channel).compile_request(
+        path: nil,
+        source:,
+        importer:,
+        load_paths:,
+        syntax:,
+        url:,
+        charset:,
+        source_map:,
+        source_map_include_sources:,
+        style:,
+        functions:,
+        importers:,
+        alert_color:,
+        alert_ascii:,
+        fatal_deprecations:,
+        future_deprecations:,
+        logger:,
+        quiet_deps:,
+        silence_deprecations:,
+        verbose:
+      )
+    end
+
+    # @return [String] Information about the Sass implementation.
+    # @see https://sass-lang.com/documentation/js-api/variables/info/
+    def info
+      @info ||= [
+        ['sass-embedded', Embedded::VERSION, '(Embedded Host)', '[Ruby]'].join("\t"),
+        Host.new(@channel).version_request.join("\t")
+      ].join("\n").freeze
+    end
+
+    def close
+      @channel.close
+    end
+
+    def closed?
+      @channel.closed?
+    end
+  end
+end