sass-embedded 0.7.27 → 0.8.2

data/lib/sass/compile.rb

@@ -1,249 +0,0 @@
-# frozen_string_literal: true
-
-module Sass
-  # The {Observer} for {Embedded#render}.
-  class CompileContext
-    include Observer
-
-    def initialize(transport, id,
-                   data:,
-                   file:,
-                   indented_syntax:,
-                   include_paths:,
-                   output_style:,
-                   source_map:,
-                   out_file:,
-                   functions:,
-                   importer:)
-      raise ArgumentError, 'either data or file must be set' if file.nil? && data.nil?
-
-      @id = id
-      @data = data
-      @file = file
-      @indented_syntax = indented_syntax
-      @include_paths = include_paths
-      @output_style = output_style
-      @source_map = source_map
-      @out_file = out_file
-      @global_functions = functions.keys
-      @functions = functions.transform_keys do |key|
-        key.to_s.split('(')[0].chomp
-      end
-      @importer = importer
-      @import_responses = {}
-
-      super(transport)
-
-      send_message compile_request
-    end
-
-    def update(error, message)
-      raise error unless error.nil?
-
-      case message
-      when EmbeddedProtocol::OutboundMessage::CompileResponse
-        return unless message.id == @id
-
-        Thread.new do
-          super(nil, message)
-        end
-      when EmbeddedProtocol::OutboundMessage::LogEvent
-        return unless message.compilation_id == @id && $stderr.tty?
-
-        warn message.formatted
-      when EmbeddedProtocol::OutboundMessage::CanonicalizeRequest
-        return unless message.compilation_id == @id
-
-        Thread.new do
-          send_message canonicalize_response message
-        end
-      when EmbeddedProtocol::OutboundMessage::ImportRequest
-        return unless message.compilation_id == @id
-
-        Thread.new do
-          send_message import_response message
-        end
-      when EmbeddedProtocol::OutboundMessage::FileImportRequest
-        raise NotImplementedError, 'FileImportRequest is not implemented'
-      when EmbeddedProtocol::OutboundMessage::FunctionCallRequest
-        return unless message.compilation_id == @id
-
-        Thread.new do
-          send_message function_call_response message
-        end
-      end
-    rescue StandardError => e
-      Thread.new do
-        super(e, nil)
-      end
-    end
-
-    private
-
-    def compile_request
-      EmbeddedProtocol::InboundMessage::CompileRequest.new(
-        id: @id,
-        string: string,
-        path: path,
-        style: style,
-        source_map: source_map,
-        importers: importers,
-        global_functions: global_functions,
-        alert_color: $stderr.tty?,
-        alert_ascii: Platform::OS == 'windows'
-      )
-    end
-
-    def canonicalize_response(canonicalize_request)
-      url = Util.file_uri_from_path(File.absolute_path(canonicalize_request.url, (@file.nil? ? 'stdin' : @file)))
-
-      begin
-        result = @importer[canonicalize_request.importer_id].call canonicalize_request.url, @file
-        raise result if result.is_a? StandardError
-      rescue StandardError => e
-        return EmbeddedProtocol::InboundMessage::CanonicalizeResponse.new(
-          id: canonicalize_request.id,
-          error: e.message
-        )
-      end
-
-      if result&.key? :contents
-        @import_responses[url] = EmbeddedProtocol::InboundMessage::ImportResponse.new(
-          id: canonicalize_request.id,
-          success: EmbeddedProtocol::InboundMessage::ImportResponse::ImportSuccess.new(
-            contents: result[:contents],
-            syntax: EmbeddedProtocol::Syntax::SCSS,
-            source_map_url: nil
-          )
-        )
-        EmbeddedProtocol::InboundMessage::CanonicalizeResponse.new(
-          id: canonicalize_request.id,
-          url: url
-        )
-      elsif result&.key? :file
-        canonicalized_url = Util.file_uri_from_path(File.absolute_path(result[:file]))
-
-        # TODO: FileImportRequest is not supported yet.
-        # Workaround by reading contents and return it when server asks
-        @import_responses[canonicalized_url] = EmbeddedProtocol::InboundMessage::ImportResponse.new(
-          id: canonicalize_request.id,
-          success: EmbeddedProtocol::InboundMessage::ImportResponse::ImportSuccess.new(
-            contents: File.read(result[:file]),
-            syntax: EmbeddedProtocol::Syntax::SCSS,
-            source_map_url: nil
-          )
-        )
-
-        EmbeddedProtocol::InboundMessage::CanonicalizeResponse.new(
-          id: canonicalize_request.id,
-          url: canonicalized_url
-        )
-      else
-        EmbeddedProtocol::InboundMessage::CanonicalizeResponse.new(
-          id: canonicalize_request.id
-        )
-      end
-    end
-
-    def import_response(import_request)
-      url = import_request.url
-
-      if @import_responses.key? url
-        @import_responses[url].id = import_request.id
-      else
-        @import_responses[url] = EmbeddedProtocol::InboundMessage::ImportResponse.new(
-          id: import_request.id,
-          error: "Failed to import: #{url}"
-        )
-      end
-
-      @import_responses[url]
-    end
-
-    def function_call_response(function_call_request)
-      # TODO: convert argument_list to **kwargs
-      EmbeddedProtocol::InboundMessage::FunctionCallResponse.new(
-        id: function_call_request.id,
-        success: @functions[function_call_request.name].call(*function_call_request.arguments),
-        accessed_argument_lists: function_call_request.arguments
-          .filter { |argument| argument.value == :argument_list }
-          .map { |argument| argument.argument_list.id }
-      )
-    rescue StandardError => e
-      EmbeddedProtocol::InboundMessage::FunctionCallResponse.new(
-        id: function_call_request.id,
-        error: e.message
-      )
-    end
-
-    def syntax
-      if @indented_syntax == true
-        EmbeddedProtocol::Syntax::INDENTED
-      else
-        EmbeddedProtocol::Syntax::SCSS
-      end
-    end
-
-    def url
-      return if @file.nil?
-
-      Util.file_uri_from_path File.absolute_path @file
-    end
-
-    def string
-      return if @data.nil?
-
-      EmbeddedProtocol::InboundMessage::CompileRequest::StringInput.new(
-        source: @data,
-        url: url,
-        syntax: syntax
-      )
-    end
-
-    def path
-      @file if @data.nil?
-    end
-
-    def style
-      case @output_style&.to_sym
-      when :expanded
-        EmbeddedProtocol::OutputStyle::EXPANDED
-      when :compressed
-        EmbeddedProtocol::OutputStyle::COMPRESSED
-      else
-        raise ArgumentError, 'output_style must be one of :expanded, :compressed'
-      end
-    end
-
-    def source_map
-      @source_map.is_a?(String) || (@source_map == true && !@out_file.nil?)
-    end
-
-    attr_reader :global_functions
-
-    # Order
-    # 1. Loading a file relative to the file in which the @use or @import appeared.
-    # 2. Each custom importer.
-    # 3. Loading a file relative to the current working directory.
-    # 4. Each load path in includePaths
-    # 5. Each load path specified in the SASS_PATH environment variable, which should
-    #    be semicolon-separated on Windows and colon-separated elsewhere.
-    def importers
-      custom_importers = @importer.map.with_index do |_, id|
-        EmbeddedProtocol::InboundMessage::CompileRequest::Importer.new(
-          importer_id: id
-        )
-      end
-
-      include_path_importers = @include_paths
-                               .concat(Sass.include_paths)
-                               .map do |include_path|
-        EmbeddedProtocol::InboundMessage::CompileRequest::Importer.new(
-          path: File.absolute_path(include_path)
-        )
-      end
-
-      custom_importers.concat include_path_importers
-    end
-  end
-end

data/lib/sass/error.rb

@@ -1,27 +0,0 @@
-# frozen_string_literal: true
-
-module Sass
-  class Error < StandardError; end
-
-  class ProtocolError < Error; end
-
-  # The {Error} raised by {Embedded#render}.
-  class RenderError < Error
-    attr_reader :formatted, :file, :line, :column, :status
-
-    def initialize(message, formatted, file, line, column, status)
-      super(message)
-      @formatted = formatted
-      @file = file
-      @line = line
-      @column = column
-      @status = status
-    end
-
-    def backtrace
-      return nil if super.nil?
-
-      ["#{@file}:#{@line}:#{@column}"] + super
-    end
-  end
-end

data/lib/sass/info.rb

@@ -1,33 +0,0 @@
-# frozen_string_literal: true
-
-module Sass
-  # The {Observer} for {Embedded#info}.
-  class VersionContext
-    include Observer
-
-    def initialize(transport, id)
-      @id = id
-
-      super(transport)
-
-      send_message EmbeddedProtocol::InboundMessage::VersionRequest.new(id: @id)
-    end
-
-    def update(error, message)
-      raise error unless error.nil?
-
-      case message
-      when EmbeddedProtocol::OutboundMessage::VersionResponse
-        return unless message.id == @id
-
-        Thread.new do
-          super(nil, message)
-        end
-      end
-    rescue StandardError => e
-      Thread.new do
-        super(e, nil)
-      end
-    end
-  end
-end

data/lib/sass/observer.rb

@@ -1,40 +0,0 @@
-# frozen_string_literal: true
-
-module Sass
-  # The {Observer} module for receiving messages from {Transport}.
-  module Observer
-    def initialize(transport)
-      @transport = transport
-      @mutex = Mutex.new
-      @condition_variable = ConditionVariable.new
-      @error = nil
-      @message = nil
-      @transport.add_observer self
-    end
-
-    def receive_message
-      @mutex.synchronize do
-        @condition_variable.wait(@mutex) if @error.nil? && @message.nil?
-      end
-
-      raise @error unless @error.nil?
-
-      @message
-    end
-
-    def update(error, message)
-      @transport.delete_observer self
-      @mutex.synchronize do
-        @error = error
-        @message = message
-        @condition_variable.broadcast
-      end
-    end
-
-    private
-
-    def send_message(message)
-      @transport.send_message(message)
-    end
-  end
-end

data/lib/sass/platform.rb

@@ -1,53 +0,0 @@
-# frozen_string_literal: true
-
-module Sass
-  module Platform
-    OS = case RbConfig::CONFIG['host_os'].downcase
-         when /linux/
-           'linux'
-         when /darwin/
-           'darwin'
-         when /freebsd/
-           'freebsd'
-         when /netbsd/
-           'netbsd'
-         when /openbsd/
-           'openbsd'
-         when /dragonfly/
-           'dragonflybsd'
-         when /sunos|solaris/
-           'solaris'
-         when /mingw|mswin/
-           'windows'
-         else
-           RbConfig::CONFIG['host_os'].downcase
-         end
-
-    OSVERSION = RbConfig::CONFIG['host_os'].gsub(/[^\d]/, '').to_i
-
-    CPU = RbConfig::CONFIG['host_cpu']
-
-    ARCH = case CPU.downcase
-           when /amd64|x86_64|x64/
-             'x86_64'
-           when /i\d86|x86|i86pc/
-             'i386'
-           when /ppc64|powerpc64/
-             'powerpc64'
-           when /ppc|powerpc/
-             'powerpc'
-           when /sparcv9|sparc64/
-             'sparcv9'
-           when /arm64|aarch64/  # MacOS calls it "arm64", other operating systems "aarch64"
-             'aarch64'
-           when /^arm/
-             if OS == 'darwin'   # Ruby before 3.0 reports "arm" instead of "arm64" as host_cpu on darwin
-               'aarch64'
-             else
-               'arm'
-             end
-           else
-             RbConfig::CONFIG['host_cpu']
-           end
-  end
-end

data/lib/sass/result.rb

@@ -1,30 +0,0 @@
-# frozen_string_literal: true
-
-module Sass
-  # The {RenderResult} of {Embedded#render}.
-  class RenderResult
-    include Struct
-
-    attr_reader :css, :map, :stats
-
-    def initialize(css, map, stats)
-      @css = css
-      @map = map
-      @stats = stats
-    end
-  end
-
-  # The {RenderResultStats} of {Embedded#render}.
-  class RenderResultStats
-    include Struct
-
-    attr_reader :entry, :start, :end, :duration
-
-    def initialize(entry, start, finish, duration)
-      @entry = entry
-      @start = start
-      @end = finish
-      @duration = duration
-    end
-  end
-end

data/lib/sass/struct.rb

@@ -1,20 +0,0 @@
-# frozen_string_literal: true
-
-module Sass
-  # The {Struct} module.
-  module Struct
-    def [](key)
-      instance_variable_get("@#{key}".to_sym)
-    end
-
-    def to_h
-      instance_variables.map do |variable|
-        [variable[1..].to_sym, instance_variable_get(variable)]
-      end.to_h
-    end
-
-    def to_s
-      to_h.to_s
-    end
-  end
-end

data/lib/sass/transport.rb

@@ -1,133 +0,0 @@
-# frozen_string_literal: true
-
-require 'open3'
-require 'observer'
-require_relative '../../ext/sass/embedded_sass_pb'
-
-module Sass
-  # The {::Observable} {Transport} for low level communication with
-  # `dart-sass-embedded` using protocol buffers via stdio. Received messages
-  # can be observed by an {Observer}.
-  class Transport
-    include Observable
-
-    DART_SASS_EMBEDDED = File.absolute_path(
-      "../../ext/sass/sass_embedded/dart-sass-embedded#{Platform::OS == 'windows' ? '.bat' : ''}", __dir__
-    )
-
-    PROTOCOL_ERROR_ID = 4_294_967_295
-
-    ONEOF_MESSAGE = EmbeddedProtocol::InboundMessage
-                    .descriptor
-                    .lookup_oneof('message')
-                    .collect do |field_descriptor|
-      [field_descriptor.subtype, field_descriptor.name]
-    end.to_h
-
-    private_constant :ONEOF_MESSAGE
-
-    def initialize
-      @observerable_mutex = Mutex.new
-      @stdin_mutex = Mutex.new
-      @stdin, @stdout, @stderr, @wait_thread = Open3.popen3(DART_SASS_EMBEDDED)
-
-      [@stdin, @stdout].each(&:binmode)
-
-      poll do
-        warn(@stderr.readline, uplevel: 1)
-      end
-      poll do
-        receive_proto read
-      end
-    end
-
-    def add_observer(*args)
-      @observerable_mutex.synchronize do
-        super(*args)
-      end
-    end
-
-    def send_message(message)
-      write EmbeddedProtocol::InboundMessage.new(
-        ONEOF_MESSAGE[message.class.descriptor] => message
-      ).to_proto
-    end
-
-    def close
-      delete_observers
-      @stdin.close unless @stdin.closed?
-      @stdout.close unless @stdout.closed?
-      @stderr.close unless @stderr.closed?
-      nil
-    end
-
-    def closed?
-      @stdin.closed?
-    end
-
-    private
-
-    def poll
-      Thread.new do
-        loop do
-          yield
-        rescue StandardError => e
-          notify_observers(e, nil)
-          close
-          break
-        end
-      end
-    end
-
-    def notify_observers(*args)
-      @observerable_mutex.synchronize do
-        changed
-        super(*args)
-      end
-    end
-
-    def receive_proto(proto)
-      payload = EmbeddedProtocol::OutboundMessage.decode(proto)
-      message = payload[payload.message.to_s]
-      case message
-      when EmbeddedProtocol::ProtocolError
-        raise ProtocolError, message.message
-      else
-        notify_observers(nil, message)
-      end
-    end
-
-    def read
-      length = read_varint(@stdout)
-      @stdout.read(length)
-    end
-
-    def write(payload)
-      @stdin_mutex.synchronize do
-        write_varint(@stdin, payload.length)
-        @stdin.write payload
-      end
-    end
-
-    def read_varint(readable)
-      value = bits = 0
-      loop do
-        byte = readable.readbyte
-        value |= (byte & 0x7f) << bits
-        bits += 7
-        break if byte < 0x80
-      end
-      value
-    end
-
-    def write_varint(writeable, value)
-      bytes = []
-      until value < 0x80
-        bytes << (0x80 | (value & 0x7f))
-        value >>= 7
-      end
-      bytes << value
-      writeable.write bytes.pack('C*')
-    end
-  end
-end

data/lib/sass/util.rb

@@ -1,31 +0,0 @@
-# frozen_string_literal: true
-
-require 'pathname'
-require 'uri'
-
-module Sass
-  # The {Util} module.
-  module Util
-    module_function
-
-    URI_PARSER = URI::Parser.new({ RESERVED: ';/?:@&=+$,' })
-
-    private_constant :URI_PARSER
-
-    def file_uri_from_path(path)
-      "file://#{Platform::OS == 'windows' ? File::SEPARATOR : ''}#{URI_PARSER.escape(path)}"
-    end
-
-    def path_from_file_uri(file_uri)
-      URI_PARSER.unescape(file_uri[(Platform::OS == 'windows' ? 8 : 7)..])
-    end
-
-    def relative_path(from, to)
-      Pathname.new(File.absolute_path(to)).relative_path_from(Pathname.new(File.absolute_path(from))).to_s
-    end
-
-    def now
-      (Time.now.to_f * 1000).to_i
-    end
-  end
-end