sass-embedded 0.2.4 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e345b143aa337d47b0f28d6d58d2a5636f84fb69b4f5ed739b6613ab39327a2d
-  data.tar.gz: 72c0bae0108414a5a989ea6b2f5eac86406eb83faa9c3fa1f1f642e609930afd
+  metadata.gz: e03d2c1775fdd10b7f9d2b21898ac0a6e31e0be96157139742384c7be9b4275a
+  data.tar.gz: dacdc9589a8da93246b791794f97be2c8818f8a492d77e473c9fa543fd49db9e
 SHA512:
-  metadata.gz: 478a33de83120ace9665efd401d9988a956a291ed19b905f77d129486fd3e796bb90a66d6e3ee4f8f1fde47eddbb285918e84f5d8795d2a9f3546c82c431ef88
-  data.tar.gz: d9512132067039d511bafc684132ae010238b0b7b9ad1c37e3d7c6a4cb6463caa620eed87b05af3fc671c9200246f81af591b82d8c0d01b38429cafb87667394
+  metadata.gz: 3be32cd37a7078fceabd16c661cf985fdfc1aa31fbf8b88e6c768cb8edd57749a30e28a77f367d6cc8c6c505710f402e1970ae6c12210b3f46fc10a42cf8d81d
+  data.tar.gz: 5a122cd7c2e883f28b9401ce70d8fb43fcfcf39e1ff64484f5bf036c6978ca1a01cf8d69b1ebbf22f0fde81f98272127cf5a96d381b0279028d316d90775ebfb

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', 'distclean')
-  require_relative 'ext/extconf'
   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/extconf.rb

@@ -8,6 +8,7 @@ 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 }
@@ -141,7 +142,7 @@ module Sass
 
       ext = 'zip'
 
-      "https://github.com/#{repo}/releases/download/#{tag_name}/protoc-#{tag_name[1..-1]}-#{os_arch}.#{ext}"
+      "https://github.com/#{repo}/releases/download/#{tag_name}/protoc-#{tag_name[1..]}-#{os_arch}.#{ext}"
     end
 
     def latest_sass_embedded_protocol

data/lib/sass.rb

@@ -1,5 +1,6 @@
 # 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
@@ -23,14 +24,21 @@ module Sass
                        end
   end
 
-  def self.render(options)
+  # 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 self.render(**kwargs)
     unless defined? @embedded
       @embedded = Sass::Embedded.new
       at_exit do
         @embedded.close
       end
     end
-    @embedded.render options
+    @embedded.render(**kwargs)
   end
 end
 

data/lib/sass/embedded.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 module Sass
+  # The interface for using dart-sass-embedded
   class Embedded
     def initialize
       @transport = Transport.new
@@ -8,198 +9,83 @@ module Sass
       @id = 0
     end
 
-    def render(options)
-      start = Sass::Util.now
+    # rubocop:disable Lint/UnusedMethodArgument
 
-      raise Sass::NotRenderedError, 'Either :data or :file must be set.' if options[:file].nil? && options[:data].nil?
+    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: [])
+      # rubocop:enable Lint/UnusedMethodArgument
 
-      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
+      start = Util.now
 
       compilation_id = next_id
 
-      compile_request = Sass::EmbeddedProtocol::InboundMessage::CompileRequest.new(
-        id: compilation_id,
-        string: string,
-        path: path,
-        style: style,
+      renderer = Renderer.new(
+        data: data,
+        file: file,
+        indented_syntax: indented_syntax,
+        include_paths: include_paths,
+        output_style: output_style,
         source_map: source_map,
-        importers: importers,
-        global_functions: options[:functions] ? signatures : [],
-        alert_color: true,
-        alert_ascii: true
+        out_file: out_file,
+        functions: functions,
+        importer: importer
       )
 
-      response = @transport.send compile_request, compilation_id
-
-      file = options[:file] || 'stdin'
-      canonicalizations = {}
-      imports = {}
+      response = @transport.send renderer.compile_request(compilation_id), compilation_id
 
       loop do
         case response
-        when Sass::EmbeddedProtocol::OutboundMessage::CompileResponse
+        when 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
-
-          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
-
-          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
-
-          response = @transport.send message, compilation_id
-        when Sass::EmbeddedProtocol::ProtocolError
-          raise Sass::ProtocolError, response.message
+        when EmbeddedProtocol::OutboundMessage::CanonicalizeRequest
+          response = @transport.send renderer.canonicalize_response(response), compilation_id
+        when EmbeddedProtocol::OutboundMessage::ImportRequest
+          response = @transport.send renderer.import_response(response), compilation_id
+        when EmbeddedProtocol::OutboundMessage::FunctionCallRequest
+          response = @transport.send renderer.function_call_response(response), compilation_id
+        when EmbeddedProtocol::ProtocolError
+          raise ProtocolError, response.message
         else
-          raise Sass::ProtocolError, "Unexpected packet received: #{response}"
+          raise ProtocolError, "Unexpected packet received: #{response}"
         end
       end
 
       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
+            response.failure.span.url == '' ? 'stdin' : URI.parse(response.failure.span.url).path
+          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
+      finish = Util.now
 
       {
         css: response.success.css,
         map: response.success.source_map,
         stats: {
-          entry: options[:file] || 'data',
+          entry: file.nil? ? 'data' : file,
           start: start,
           end: finish,
           duration: finish - start
@@ -215,7 +101,7 @@ module Sass
     private
 
     def info
-      version_response = @transport.send Sass::EmbeddedProtocol::InboundMessage::VersionRequest.new(
+      version_response = @transport.send EmbeddedProtocol::InboundMessage::VersionRequest.new(
         id: next_id
       )
       {
@@ -233,5 +119,199 @@ module Sass
         @id
       end
     end
+
+    # Helper class that maintains render state
+    class Renderer
+      def initialize(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 = {}
+      end
+
+      def compile_request(id)
+        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
+
+      private
+
+      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