sass-embedded 0.8.0 → 0.9.1

data/lib/sass/embedded/compile_context.rb

@@ -0,0 +1,254 @@
+# frozen_string_literal: true
+
+require_relative '../embedded_protocol'
+require_relative 'observer'
+require_relative 'util'
+
+module Sass
+  class Embedded
+    # The {Observer} for {Embedded#render}.
+    class CompileContext
+      include Observer
+
+      def initialize(channel,
+                     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?
+
+        @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(channel)
+
+        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(Embedded.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
+end

data/lib/sass/embedded/compiler/path.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require_relative '../platform'
+
+module Sass
+  class Embedded
+    class Compiler
+      PATH = File.absolute_path(
+        "../../../../ext/sass/sass_embedded/dart-sass-embedded#{Platform::OS == 'windows' ? '.bat' : ''}", __dir__
+      )
+    end
+  end
+end

data/lib/sass/embedded/compiler/requirements.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Sass
+  class Embedded
+    class Compiler
+      REQUIREMENTS = '~> 1.0.0-beta.12'
+    end
+  end
+end

data/lib/sass/embedded/compiler.rb

@@ -0,0 +1,156 @@
+# frozen_string_literal: true
+
+require 'observer'
+require 'open3'
+require_relative '../embedded_protocol'
+require_relative 'compiler/path'
+require_relative 'error'
+
+module Sass
+  class Embedded
+    # The {::Observable} {Compiler} for low level communication with
+    # `dart-sass-embedded` using protocol buffers via stdio. Received messages
+    # can be observed by an {Observer}.
+    class Compiler
+      include Observable
+
+      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
+        @id = 0
+        @stdin_mutex = Mutex.new
+        @stdin, @stdout, @stderr, @wait_thread = Open3.popen3(PATH)
+
+        [@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
+          raise IOError, 'half-closed compiler' if half_closed?
+
+          super(*args)
+
+          id = @id
+          @id = @id.next
+          id
+        end
+      end
+
+      def delete_observer(*args)
+        @observerable_mutex.synchronize do
+          super(*args)
+
+          close if half_closed? && count_observers.zero?
+        end
+      end
+
+      def send_message(message)
+        write EmbeddedProtocol::InboundMessage.new(
+          ONEOF_MESSAGE[message.class.descriptor] => message
+        ).to_proto
+      end
+
+      def close
+        delete_observers
+
+        @stdin_mutex.synchronize do
+          @stdin.close unless @stdin.closed?
+          @stdout.close unless @stdout.closed?
+          @stderr.close unless @stderr.closed?
+        end
+
+        @wait_thread.value
+      end
+
+      def closed?
+        @stdin_mutex.synchronize do
+          @stdin.closed?
+        end
+      end
+
+      private
+
+      def half_closed?
+        @id == EmbeddedProtocol::PROTOCOL_ERROR_ID
+      end
+
+      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
+end

data/lib/sass/embedded/error.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Sass
+  class Embedded
+    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
+end

data/lib/sass/embedded/observer.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Sass
+  class Embedded
+    # The {Observer} module for communicating with {Compiler}.
+    module Observer
+      def initialize(channel)
+        @mutex = Mutex.new
+        @condition_variable = ConditionVariable.new
+        @error = nil
+        @message = nil
+
+        @subscription = channel.subscribe(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)
+        @subscription.unsubscribe
+        @mutex.synchronize do
+          @error = error
+          @message = message
+          @condition_variable.broadcast
+        end
+      end
+
+      private
+
+      def id
+        @subscription.id
+      end
+
+      def send_message(*args)
+        @subscription.send_message(*args)
+      end
+    end
+  end
+end

data/lib/sass/embedded/platform.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module Sass
+  class Embedded
+    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
+end

data/lib/sass/embedded/result.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require_relative 'struct'
+
+module Sass
+  class Embedded
+    # 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
+end

data/lib/sass/embedded/struct.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Sass
+  class Embedded
+    # 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
+end

data/lib/sass/embedded/util.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require 'pathname'
+require 'uri'
+
+module Sass
+  class Embedded
+    # The {Util} module.
+    module Util
+      URI_PARSER = URI::Parser.new({ RESERVED: ';/?:@&=+$,' })
+
+      private_constant :URI_PARSER
+
+      module_function
+
+      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
+end

data/lib/sass/{version.rb → embedded/version.rb}

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
 module Sass
-  VERSION = '0.8.0'
+  class Embedded
+    VERSION = '0.9.1'
+  end
 end

data/lib/sass/embedded/version_context.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require_relative '../embedded_protocol'
+require_relative 'observer'
+
+module Sass
+  class Embedded
+    # The {Observer} for {Embedded#info}.
+    class VersionContext
+      include Observer
+
+      def initialize(channel)
+        super(channel)
+
+        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
+end