sass-embedded 0.2.3 → 0.4.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5dc860ffde1f3fb6315c2a43972b245841e10e0b0b4a8979a5a4c7528063cd95
-  data.tar.gz: aa76a73fdc4a252b1cd948b90452fa772282408289e99a4e0206c968a5e68898
+  metadata.gz: c03a96231c8305e27f3deb1a35e308808482159a5dd25b4c8191da9c1b25500d
+  data.tar.gz: d6ba46dd80433759554a8c83d1fe8a8b4fd66461ffb063c859011d4ab4e3b6cc
 SHA512:
-  metadata.gz: b03c95f66214d6e095fd1e11bbeebe24d56443cf90107661007aef30006502296799c07e4c73974cfa0ca7debc7a807a120c86eb99441363af10f699a9cd0148
-  data.tar.gz: b834e3e9e2a0eb7acdea42e04c1627edc86f2e146c0b96e79331c646b387f8df861fa59d0efeb46d9f3d176b388804d67b63515cc406efb8bb5d7a3c1d4391f6
+  metadata.gz: a4be81866a1672fd02da1cf1c66d08a2a0dd50cb002ee1b6fd0cce4d70c4e02222c11662a69307e7e33c58bf1dedc968d7ec72b2ebb3fa35296b1520896be2f5
+  data.tar.gz: 39b348a11dd2277bb43e7bd936b08462057caac6180cb5b0548384cb64da47d1255606d8ce0a0ab2d0a4d891efee26cff190568eec1a782426011c4fc15ac2b0

data/.github/workflows/build.yml

@@ -41,4 +41,4 @@ jobs:
 
     - name: Test Gem
       run: |-
-        ruby -r sass -e "puts Sass.render({ data: 'h1 { color: black; }' })[:css]"
+        ruby -r sass -e "puts Sass.render(data: 'h1 { color: black; }')[:css]"

data/.rubocop.yml

@@ -0,0 +1,14 @@
+AllCops:
+  Exclude:
+    - '**/*_pb.rb'
+    - 'vendor/**/*'
+
+  TargetRubyVersion: 2.6
+
+  NewCops: enable
+
+Layout/LineLength:
+  Enabled: false
+
+Metrics:
+  Enabled: false

data/README.md

@@ -11,9 +11,7 @@ It exposes a Ruby API for Sass that's backed by a native [Dart Sass](https://sas
 ``` ruby
 require "sass"
 
-Sass.render({
-  file: "style.scss"
-})
+Sass.render(file: "style.scss")
 ```
 
 ---

data/Rakefile

@@ -2,17 +2,22 @@
 
 require 'bundler/gem_tasks'
 
-task default: :test
+task default: %i[rubocop test]
 
 desc 'Download dart-sass-embedded'
 task :extconf do
-  system('make', '-C', 'ext/sass_embedded', 'distclean')
-  require_relative 'ext/sass_embedded/extconf'
-  system('make', '-C', 'ext/sass_embedded', 'install')
+  system('make', '-C', 'ext')
 end
 
 desc 'Run all tests'
-task :test do
+task test: :extconf do
   $LOAD_PATH.unshift('lib', 'test')
   Dir.glob('./test/**/*_test.rb').sort.each { |f| require f }
 end
+
+begin
+  require 'rubocop/rake_task'
+  RuboCop::RakeTask.new
+rescue LoadError
+  nil
+end

data/ext/Makefile

@@ -0,0 +1,51 @@
+ifeq ($(OS),Windows_NT)
+RM = cmd /c del /f /q /s
+else
+RM = rm -fr
+endif
+EXTCONF = ruby -- extconf.rb --without-sass-embedded --without-sass-embedded-protocol --without-protoc
+
+.PHONY: all
+all: sass_embedded embedded_sass_pb.rb
+
+.PHONY: install
+install:
+
+.PHONY: clean
+clean:
+	$(RM) embedded_sass_pb.rb protoc sass_embedded
+
+.PHONY: distclean
+distclean: clean
+	$(RM) embedded_sass.proto protoc-*.zip sass_embedded-*.tar.gz
+
+ifeq ($(OS),Windows_NT)
+sass_embedded-*.zip:
+else
+sass_embedded-*.tar.gz:
+endif
+	$(EXTCONF) --with-sass-embedded
+
+ifeq ($(OS),Windows_NT)
+sass_embedded: sass_embedded-*.zip
+	powershell -c "Get-Item $< | Expand-Archive -DestinationPath . -Force"
+else
+sass_embedded: sass_embedded-*.tar.gz
+	tar -vxzf $<
+endif
+
+protoc-*.zip:
+	$(EXTCONF) --with-protoc
+
+protoc: protoc-*.zip
+ifeq ($(OS),Windows_NT)
+	powershell -c "Get-Item $< | Expand-Archive -DestinationPath $@ -Force"
+else
+	unzip -od $@ $<
+endif
+
+embedded_sass.proto:
+	$(EXTCONF) --with-sass-embedded-protocol
+
+%_pb.rb: %.proto protoc
+	./protoc/bin/protoc --ruby_out=. $<

data/ext/extconf.rb

@@ -0,0 +1,160 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'mkmf'
+require 'json'
+require 'open-uri'
+require 'fileutils'
+require_relative '../lib/sass/platform'
+
+module Sass
+  # Install dependencies for sass-embedded during gem install
+  class Extconf
+    def initialize
+      get_with_config('sass-embedded', true) { latest_sass_embedded }
+      get_with_config('sass-embedded-protocol', true) { latest_sass_embedded_protocol }
+      get_with_config('protoc', true) { latest_protoc }
+    end
+
+    private
+
+    def get_with_config(config, default)
+      val = with_config(config, default)
+      case val
+      when true
+        if block_given?
+          get yield
+        else
+          get default
+        end
+      when false
+        nil
+      else
+        get val
+      end
+    end
+
+    def get(uri_s)
+      uri = URI.parse(uri_s)
+      path = File.absolute_path(File.basename(uri.path), __dir__)
+      if uri.is_a?(URI::File) || uri.instance_of?(URI::Generic)
+        FileUtils.copy_file uri.path, path
+      elsif uri.respond_to? :open
+        uri.open do |source|
+          File.open(path, 'wb') do |destination|
+            destination.write source.read
+          end
+        end
+      else
+        raise
+      end
+    rescue StandardError
+      raise "Failed to get: #{uri}"
+    end
+
+    def latest_release(repo, prerelease: false)
+      if prerelease
+        headers = {}
+        headers['Authorization'] = "token #{ENV['GITHUB_TOKEN']}" if ENV['GITHUB_TOKEN']
+        URI.parse("https://api.github.com/repos/#{repo}/releases").open(headers) do |file|
+          JSON.parse(file.read)[0]['tag_name']
+        end
+      else
+        URI.parse("https://github.com/#{repo}/releases/latest").open do |file|
+          File.basename file.base_uri.to_s
+        end
+      end
+    end
+
+    def latest_sass_embedded
+      repo = 'sass/dart-sass-embedded'
+
+      # TODO, don't use prerelease once a release is available
+      tag_name = latest_release repo, prerelease: true
+
+      os = case Sass::Platform::OS
+           when 'darwin'
+             'macos'
+           when 'linux'
+             'linux'
+           when 'windows'
+             'windows'
+           else
+             raise "Unsupported OS: #{Sass::Platform::OS}"
+           end
+
+      arch = case Sass::Platform::ARCH
+             when 'x86_64'
+               'x64'
+             when 'i386'
+               'ia32'
+             else
+               raise "Unsupported Arch: #{Sass::Platform::ARCH}"
+             end
+
+      ext = case os
+            when 'windows'
+              'zip'
+            else
+              'tar.gz'
+            end
+
+      "https://github.com/#{repo}/releases/download/#{tag_name}/sass_embedded-#{tag_name}-#{os}-#{arch}.#{ext}"
+    end
+
+    def latest_protoc
+      repo = 'protocolbuffers/protobuf'
+
+      tag_name = latest_release repo
+
+      os = case Sass::Platform::OS
+           when 'darwin'
+             'osx'
+           when 'linux'
+             'linux'
+           when 'windows'
+             'win'
+           else
+             raise "Unsupported OS: #{Sass::Platform::OS}"
+           end
+
+      arch = case Sass::Platform::ARCH
+             when 'aarch64'
+               'aarch_64'
+             when 'sparcv9'
+               's390'
+             when 'i386'
+               'x86_32'
+             when 'x86_64'
+               'x86_64'
+             when 'powerpc64'
+               'ppcle_64'
+             else
+               raise "Unsupported Arch: #{Sass::Platform::ARCH}"
+             end
+
+      os_arch = case os
+                when 'win'
+                  os + arch.split('_').last
+                else
+                  "#{os}-#{arch}"
+                end
+
+      ext = 'zip'
+
+      "https://github.com/#{repo}/releases/download/#{tag_name}/protoc-#{tag_name[1..]}-#{os_arch}.#{ext}"
+    end
+
+    def latest_sass_embedded_protocol
+      repo = 'sass/embedded-protocol'
+
+      # TODO: use latest release once available
+      # tag_name = latest_release repo
+      tag_name = 'HEAD'
+
+      "https://raw.githubusercontent.com/#{repo}/#{tag_name}/embedded_sass.proto"
+    end
+  end
+end
+
+Sass::Extconf.new

data/lib/sass.rb

@@ -1,36 +1,52 @@
 # frozen_string_literal: true
 
+# The Sass module
 module Sass
-  # The global include_paths for Sass files. This is meant for plugins and
-  # libraries to register the paths to their Sass stylesheets to that they may
-  # be `@imported`. This include path is used by every instance of
-  # {Sass::Embedded}. They are lower-precedence than any include paths passed
-  # in via the `:include_paths` option.
-  #
-  # If the `SASS_PATH` environment variable is set,
-  # the initial value of `include_paths` will be initialized based on that.
-  # The variable should be a colon-separated list of path names
-  # (semicolon-separated on Windows).
-  #
-  # @example
-  #   Sass.include_paths << File.dirname(__FILE__) + '/sass'
-  # @return [Array<String, Pathname>]
-  def self.include_paths
-    @include_paths ||= if ENV['SASS_PATH']
-                         ENV['SASS_PATH'].split(File::PATH_SEPARATOR)
-                       else
-                         []
-                       end
-  end
+  class << self
+    # The global include_paths for Sass files. This is meant for plugins and
+    # libraries to register the paths to their Sass stylesheets to that they may
+    # be `@imported`. This include path is used by every instance of
+    # {Sass::Embedded}. They are lower-precedence than any include paths passed
+    # in via the `:include_paths` option.
+    #
+    # If the `SASS_PATH` environment variable is set,
+    # the initial value of `include_paths` will be initialized based on that.
+    # The variable should be a colon-separated list of path names
+    # (semicolon-separated on Windows).
+    #
+    # @example
+    #   Sass.include_paths << File.dirname(__FILE__) + '/sass'
+    # @return [Array<String, Pathname>]
+    def include_paths
+      @include_paths ||= if ENV['SASS_PATH']
+                           ENV['SASS_PATH'].split(File::PATH_SEPARATOR)
+                         else
+                           []
+                         end
+    end
+
+    def info
+      embedded.info
+    end
+
+    # The global render methods. This method automatically instantiates a
+    # global {Sass::Embedded} instance when invoked the first time and call
+    # `:render` method on the instance thereafter. The global {Sass::Embedded}
+    # is automatically closed via {Kernel.at_exit}.
+    # @example
+    #   Sass.render(options)
+    # @return [Hash]
+    def render(**kwargs)
+      embedded.render(**kwargs)
+    end
+
+    private
+
+    def embedded
+      return @embedded if defined?(@embedded) && !@embedded.closed?
 
-  def self.render(options)
-    unless defined? @embedded
       @embedded = Sass::Embedded.new
-      at_exit do
-        @embedded.close
-      end
     end
-    @embedded.render options
   end
 end
 
@@ -39,4 +55,5 @@ require_relative 'sass/error'
 require_relative 'sass/platform'
 require_relative 'sass/util'
 require_relative 'sass/transport'
+require_relative 'sass/context'
 require_relative 'sass/embedded'

data/lib/sass/context.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Sass
+  # An abstract context for maintaining state and observing transport
+  class Context
+    def initialize(transport, id)
+      raise NotImplementedError if instance_of? Context
+
+      @transport = transport
+      @id = id
+      @mutex = Mutex.new
+      @condition_variable = ConditionVariable.new
+      @response = nil
+      @error = nil
+      @transport.add_observer self
+    end
+
+    def fetch
+      @mutex.synchronize do
+        @condition_variable.wait(@mutex) if @error.nil? && @response.nil?
+      end
+
+      raise @error unless @error.nil?
+
+      @response
+    end
+
+    def update(error, message)
+      @transport.delete_observer self
+      @mutex.synchronize do
+        @error = error
+        @response = message
+        @condition_variable.broadcast
+      end
+    end
+  end
+end

data/lib/sass/embedded.rb

@@ -1,6 +1,10 @@
 # frozen_string_literal: true
 
+require 'json'
+require 'base64'
+
 module Sass
+  # The interface for using dart-sass-embedded
   class Embedded
     def initialize
       @transport = Transport.new
@@ -8,198 +12,85 @@ module Sass
       @id = 0
     end
 
-    def render(options)
-      start = Sass::Util.now
-
-      raise Sass::NotRenderedError, 'Either :data or :file must be set.' if options[:file].nil? && options[:data].nil?
-
-      string = if options[:data]
-                 Sass::EmbeddedProtocol::InboundMessage::CompileRequest::StringInput.new(
-                   source: options[:data],
-                   url: options[:file] ? Sass::Util.file_uri(options[:file]) : 'stdin',
-                   syntax: options[:indented_syntax] == true ? Sass::EmbeddedProtocol::Syntax::INDENTED : Sass::EmbeddedProtocol::Syntax::SCSS
-                 )
-               end
-
-      path = options[:data] ? nil : options[:file]
-
-      style = case options[:output_style]&.to_sym
-              when :expanded, nil
-                Sass::EmbeddedProtocol::OutputStyle::EXPANDED
-              when :compressed
-                Sass::EmbeddedProtocol::OutputStyle::COMPRESSED
-              when :nested, :compact
-                raise Sass::UnsupportedValue, "#{options[:output_style]} is not a supported :output_style"
-              else
-                raise Sass::InvalidStyleError, "#{options[:output_style]} is not a valid :output_style"
-              end
-
-      source_map = options[:source_map].is_a?(String) || (options[:source_map] == true && !options[:out_file].nil?)
-
-      # 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.
-      importers = (if options[:importer]
-                     [
-                       Sass::EmbeddedProtocol::InboundMessage::CompileRequest::Importer.new(importer_id: 0)
-                     ]
-                   else
-                     []
-                   end).concat(
-                     (options[:include_paths] || []).concat(Sass.include_paths)
-                     .map do |include_path|
-                       Sass::EmbeddedProtocol::InboundMessage::CompileRequest::Importer.new(
-                         path: File.absolute_path(include_path)
-                       )
-                     end
-                   )
-
-      signatures = []
-      functions = {}
-      options[:functions]&.each do |signature, function|
-        signatures.push signature
-        functions[signature.to_s.split('(')[0].chomp] = function
-      end
-
-      compilation_id = next_id
-
-      compile_request = Sass::EmbeddedProtocol::InboundMessage::CompileRequest.new(
-        id: compilation_id,
-        string: string,
-        path: path,
-        style: style,
-        source_map: source_map,
-        importers: importers,
-        global_functions: options[:functions] ? signatures : [],
-        alert_color: true,
-        alert_ascii: true
-      )
-
-      response = @transport.send compile_request, compilation_id
-
-      file = options[:file] || 'stdin'
-      canonicalizations = {}
-      imports = {}
-
-      loop do
-        case response
-        when Sass::EmbeddedProtocol::OutboundMessage::CompileResponse
-          break
-        when Sass::EmbeddedProtocol::OutboundMessage::CanonicalizeRequest
-          url = Sass::Util.file_uri(File.absolute_path(response.url, File.dirname(file)))
-
-          if canonicalizations.key? url
-            canonicalizations[url].id = response.id
-          else
-            resolved = nil
-            options[:importer].each do |importer|
-              begin
-                resolved = importer.call response.url, file
-              rescue StandardError => e
-                resolved = e
-              end
-              break if resolved
-            end
-            if resolved.nil?
-              canonicalizations[url] = Sass::EmbeddedProtocol::InboundMessage::CanonicalizeResponse.new(
-                id: response.id,
-                url: url
-              )
-            elsif resolved.is_a? StandardError
-              canonicalizations[url] = Sass::EmbeddedProtocol::InboundMessage::CanonicalizeResponse.new(
-                id: response.id,
-                error: resolved.message
-              )
-            elsif resolved.key? :contents
-              canonicalizations[url] = Sass::EmbeddedProtocol::InboundMessage::CanonicalizeResponse.new(
-                id: response.id,
-                url: url
-              )
-              imports[url] = Sass::EmbeddedProtocol::InboundMessage::ImportResponse.new(
-                id: response.id,
-                success: Sass::EmbeddedProtocol::InboundMessage::ImportResponse::ImportSuccess.new(
-                  contents: resolved[:contents],
-                  syntax: Sass::EmbeddedProtocol::Syntax::SCSS,
-                  source_map_url: nil
-                )
-              )
-            elsif resolved.key? :file
-              canonicalized_url = Sass::Util.file_uri(resolved[:file])
-              canonicalizations[url] = Sass::EmbeddedProtocol::InboundMessage::CanonicalizeResponse.new(
-                id: response.id,
-                url: canonicalized_url
-              )
-              imports[canonicalized_url] = Sass::EmbeddedProtocol::InboundMessage::ImportResponse.new(
-                id: response.id,
-                success: Sass::EmbeddedProtocol::InboundMessage::ImportResponse::ImportSuccess.new(
-                  contents: File.read(resolved[:file]),
-                  syntax: Sass::EmbeddedProtocol::Syntax::SCSS,
-                  source_map_url: nil
-                )
-              )
-            else
-              canonicalizations[url] = Sass::EmbeddedProtocol::InboundMessage::CanonicalizeResponse.new(
-                id: response.id,
-                error: "Unexpected value returned from importer: #{resolved}"
-              )
-            end
-          end
-
-          response = @transport.send canonicalizations[url], compilation_id
-        when Sass::EmbeddedProtocol::OutboundMessage::ImportRequest
-          url = response.url
+    def info
+      @info ||= InfoContext.new(@transport, next_id).fetch
+    end
 
-          if imports.key? url
-            imports[url].id = response.id
-          else
-            imports[url] = Sass::EmbeddedProtocol::InboundMessage::ImportResponse.new(
-              id: response.id,
-              error: "Failed to import: #{url}"
-            )
-          end
+    def render(data: nil,
+               file: nil,
+               indented_syntax: false,
+               include_paths: [],
+               output_style: :expanded,
+               # precision: 5,
+               indent_type: :space,
+               indent_width: 2,
+               linefeed: :lf,
+               # source_comments: false,
+               source_map: false,
+               out_file: nil,
+               omit_source_map_url: false,
+               # source_map_contents: false,
+               source_map_embed: false,
+               source_map_root: '',
+               functions: {},
+               importer: [])
+      start = Util.now
 
-          response = @transport.send imports[url], compilation_id
-        when Sass::EmbeddedProtocol::OutboundMessage::FunctionCallRequest
-          begin
-            message = Sass::EmbeddedProtocol::InboundMessage::FunctionCallResponse.new(
-              id: response.id,
-              success: functions[response.name].call(*response.arguments)
-            )
-          rescue StandardError => e
-            message = Sass::EmbeddedProtocol::InboundMessage::FunctionCallResponse.new(
-              id: response.id,
-              error: e.message
-            )
-          end
+      indent_type = parse_indent_type(indent_type)
+      indent_width = parse_indent_width(indent_width)
+      linefeed = parse_linefeed(linefeed)
 
-          response = @transport.send message, compilation_id
-        when Sass::EmbeddedProtocol::ProtocolError
-          raise Sass::ProtocolError, response.message
-        else
-          raise Sass::ProtocolError, "Unexpected packet received: #{response}"
-        end
-      end
+      response = RenderContext.new(@transport, next_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,
+                                   functions: functions,
+                                   importer: importer).fetch
 
       if response.failure
-        raise Sass::CompilationError.new(
+        raise RenderError.new(
           response.failure.message,
           response.failure.formatted,
-          response.failure.span ? response.failure.span.url : nil,
+          if response.failure.span.nil?
+            nil
+          elsif response.failure.span.url == ''
+            'stdin'
+          else
+            Util.path(response.failure.span.url)
+          end,
           response.failure.span ? response.failure.span.start.line + 1 : nil,
           response.failure.span ? response.failure.span.start.column + 1 : nil,
           1
         )
       end
 
-      finish = Sass::Util.now
+      map, source_map = post_process_map(map: response.success.source_map,
+                                         file: file,
+                                         out_file: out_file,
+                                         source_map: source_map,
+                                         source_map_root: source_map_root)
+
+      css = post_process_css(css: response.success.css,
+                             indent_type: indent_type,
+                             indent_width: indent_width,
+                             linefeed: linefeed,
+                             map: map,
+                             out_file: out_file,
+                             omit_source_map_url: omit_source_map_url,
+                             source_map: source_map,
+                             source_map_embed: source_map_embed)
+
+      finish = Util.now
 
       {
-        css: response.success.css,
-        map: response.success.source_map,
+        css: css,
+        map: map,
         stats: {
-          entry: options[:file] || 'data',
+          entry: file.nil? ? 'data' : file,
           start: start,
           end: finish,
           duration: finish - start
@@ -209,21 +100,116 @@ module Sass
 
     def close
       @transport.close
-      nil
+    end
+
+    def closed?
+      @transport.closed?
     end
 
     private
 
-    def info
-      version_response = @transport.send Sass::EmbeddedProtocol::InboundMessage::VersionRequest.new(
-        id: next_id
-      )
-      {
-        compiler_version: version_response.compiler_version,
-        protocol_version: version_response.protocol_version,
-        implementation_name: version_response.implementation_name,
-        implementation_version: version_response.implementation_version
-      }
+    def post_process_map(map:,
+                         file:,
+                         out_file:,
+                         source_map:,
+                         source_map_root:)
+      return if map.nil? || map.empty?
+
+      map_data = JSON.parse(map)
+
+      map_data['sourceRoot'] = source_map_root
+
+      source_map_path = if source_map.is_a? String
+                          source_map
+                        else
+                          "#{out_file}.map"
+                        end
+
+      source_map_dir = File.dirname(source_map_path)
+
+      if out_file
+        map_data['file'] = Util.relative(source_map_dir, out_file)
+      elsif file
+        ext = File.extname(file)
+        map_data['file'] = "#{file[0..(ext.empty? ? -1 : -ext.length - 1)]}.css"
+      else
+        map_data['file'] = 'stdin.css'
+      end
+
+      map_data['sources'].map! do |source|
+        if source.start_with? Util::FILE_PROTOCOL
+          Util.relative(source_map_dir, Util.path(source))
+        else
+          source
+        end
+      end
+
+      [-JSON.generate(map_data), source_map_path]
+    end
+
+    def post_process_css(css:,
+                         indent_type:,
+                         indent_width:,
+                         linefeed:,
+                         map:,
+                         omit_source_map_url:,
+                         out_file:,
+                         source_map:,
+                         source_map_embed:)
+      css = +css
+      if indent_width != 2 || indent_type.to_sym != :space
+        indent = indent_type * indent_width
+        css.gsub!(/^ +/) do |space|
+          indent * (space.length / 2)
+        end
+      end
+      css.gsub!("\n", linefeed) if linefeed != "\n"
+
+      unless map.nil? || omit_source_map_url == true
+        url = if source_map_embed
+                "data:application/json;base64,#{Base64.strict_encode64(map)}"
+              elsif out_file
+                Util.relative(File.dirname(out_file), source_map)
+              else
+                source_map
+              end
+        css += "#{linefeed}/*# sourceMappingURL=#{url} */"
+      end
+
+      -css
+    end
+
+    def parse_indent_type(indent_type)
+      case indent_type.to_sym
+      when :space
+        ' '
+      when :tab
+        "\t"
+      else
+        raise ArgumentError, 'indent_type must be :space or :tab'
+      end
+    end
+
+    def parse_indent_width(indent_width)
+      raise ArgumentError, 'indent_width must be an integer' unless indent_width.is_a? Integer
+      raise RangeError, 'indent_width must be in between 0 and 10 (inclusive)' unless indent_width.between? 0, 10
+
+      indent_width
+    end
+
+    def parse_linefeed(linefeed)
+      case linefeed.to_sym
+      when :lf
+        "\n"
+      when :lfcr
+        "\n\r"
+      when :cr
+        "\r"
+      when :crlf
+        "\r\n"
+      else
+        raise ArgumentError, 'linefeed must be one of :lf, :lfcr, :cr, :crlf'
+      end
     end
 
     def next_id
@@ -233,5 +219,276 @@ module Sass
         @id
       end
     end
+
+    # InfoContext
+    class InfoContext < Context
+      def initialize(transport, id)
+        super(transport, id)
+        @transport.send EmbeddedProtocol::InboundMessage::VersionRequest.new(id: @id)
+      end
+
+      def update(error, message)
+        raise error unless error.nil?
+
+        response = message[message.message.to_s]
+
+        case response
+        when EmbeddedProtocol::ProtocolError
+          raise ProtocolError, response.message
+        when EmbeddedProtocol::OutboundMessage::VersionResponse
+          return unless response.id == @id
+
+          Thread.new do
+            super(nil, response)
+          end
+        end
+      rescue StandardError => e
+        Thread.new do
+          super(e, nil)
+        end
+      end
+    end
+
+    # RenderContext
+    class RenderContext < Context
+      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?
+
+        super(transport, 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 = {}
+
+        @transport.send compile_request
+      end
+
+      def update(error, message)
+        raise error unless error.nil?
+
+        response = message[message.message.to_s]
+
+        case response
+        when EmbeddedProtocol::ProtocolError
+          raise ProtocolError, response.message
+        when EmbeddedProtocol::OutboundMessage::CompileResponse
+          return unless response.id == @id
+
+          Thread.new do
+            super(nil, response)
+          end
+        when EmbeddedProtocol::OutboundMessage::LogEvent
+          # not implemented yet
+        when EmbeddedProtocol::OutboundMessage::CanonicalizeRequest
+          return unless response['compilation_id'] == @id
+
+          Thread.new do
+            @transport.send canonicalize_response(response)
+          end
+        when EmbeddedProtocol::OutboundMessage::ImportRequest
+          return unless response['compilation_id'] == @id
+
+          Thread.new do
+            @transport.send import_response(response)
+          end
+        when EmbeddedProtocol::OutboundMessage::FileImportRequest
+          raise NotImplementedError, 'FileImportRequest is not implemented'
+        when EmbeddedProtocol::OutboundMessage::FunctionCallRequest
+          return unless response['compilation_id'] == @id
+
+          Thread.new do
+            @transport.send function_call_response(response)
+          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(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(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)
+        EmbeddedProtocol::InboundMessage::FunctionCallResponse.new(
+          id: function_call_request.id,
+          success: @functions[function_call_request.name].call(*function_call_request.arguments)
+        )
+      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 @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
+        when :nested, :compact
+          raise ArgumentError, "#{@output_style} is not a supported output_style"
+        else
+          raise ArgumentError, "#{@output_style} is not a valid utput_style"
+        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
 end