sass-embedded 0.2.4 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e345b143aa337d47b0f28d6d58d2a5636f84fb69b4f5ed739b6613ab39327a2d
-  data.tar.gz: 72c0bae0108414a5a989ea6b2f5eac86406eb83faa9c3fa1f1f642e609930afd
+  metadata.gz: d1086f5483670120b40e9741187e5150a5af9e9ad5d38159d6d57459edec350b
+  data.tar.gz: d6afead31f102a04ad4d11c82e1381b597c285ae0206564640763173e2b67fc6
 SHA512:
-  metadata.gz: 478a33de83120ace9665efd401d9988a956a291ed19b905f77d129486fd3e796bb90a66d6e3ee4f8f1fde47eddbb285918e84f5d8795d2a9f3546c82c431ef88
-  data.tar.gz: d9512132067039d511bafc684132ae010238b0b7b9ad1c37e3d7c6a4cb6463caa620eed87b05af3fc671c9200246f81af591b82d8c0d01b38429cafb87667394
+  metadata.gz: c8c534da41310d6b7e6228624d26a6e3dd94bccc4b67b2e9a25bff82251cb3b4a5d312c58ec1e498f944731cc99f4fdcb66b117278640cee2fc3d81f95924f66
+  data.tar.gz: 6d8808fc65dbb7fc4b43976beb6c8573635d874e9d72a7949f20eda5406e582ea0933a99f844256ec284e3ecf1e8e6f02b967f50854fde661470bf6834550abb

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,11 @@
+AllCops:
+  Exclude:
+    - '**/*_pb.rb'
+    - 'vendor/**/*'
+
+  TargetRubyVersion: 2.6
+
+  NewCops: enable
+
+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,11 +8,24 @@ require 'fileutils'
 require_relative '../lib/sass/platform'
 
 module Sass
+  # The dependency downloader. This will download all the dependencies
+  # during gem installation, and the Makefile will unpack all downloaded
+  # dependencies. By default it will download the latest release of each
+  # dependency from GitHub releases.
+  #
+  # It is possible to specify an alternative source or version of each
+  # dependency. Local sources can be used for offline installation.
+  #
+  # @example
+  #   gem install sass-embedded -- \
+  #     --with-protoc=file:///path/to/protoc-*.zip
+  #     --with-sass-embedded=file:///path/to/sass_embedded-*.(tar.gz|zip) \
+  #     --with-sass-embedded-protocol=file:///path/to/embedded_sass.proto \
   class Extconf
     def initialize
+      get_with_config('protoc', true) { latest_protoc }
       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
@@ -141,7 +154,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,36 +1,55 @@
 # frozen_string_literal: true
 
+# The Sass module. This module will communicate with Embedded Dart Sass using
+# the Embedded Sass protocol.
 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 method. This method automatically instantiates a
+    # global {Sass::Embedded} instance when invoked the first time and call
+    # `:render` method on the instance thereafter. See {Sass::Embedded#render}
+    # for supported options.
+    # @example
+    #   Sass.render(data: 'h1 { font-size: 40px; }')
+    # @example
+    #   Sass.render(file: 'style.css')
+    # @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 +58,7 @@ require_relative 'sass/error'
 require_relative 'sass/platform'
 require_relative 'sass/util'
 require_relative 'sass/transport'
+require_relative 'sass/observer'
+require_relative 'sass/info'
+require_relative 'sass/render'
 require_relative 'sass/embedded'

data/lib/sass/embedded.rb

@@ -1,6 +1,16 @@
 # frozen_string_literal: true
 
+require 'base64'
+require 'json'
+
 module Sass
+  # The {Embedded} user interface for using dart-sass-embedded. Each instance
+  # will create its own {Transport}.
+  # @example
+  #   embedded = Sass::Embedded.new
+  #   result = embedded.render(data: 'h1 { font-size: 40px; }')
+  #   result = embedded.render(file: 'style.css')
+  #   embedded.close
   class Embedded
     def initialize
       @transport = Transport.new
@@ -8,198 +18,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
+    def info
+      @info ||= Info.new(@transport, next_id).fetch
+    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
+    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
+
+      indent_type = parse_indent_type(indent_type)
+      indent_width = parse_indent_width(indent_width)
+      linefeed = parse_linefeed(linefeed)
+
+      result = Render.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 result.failure
+        raise RenderError.new(
+          result.failure.message,
+          result.failure.formatted,
+          if result.failure.span.nil?
+            nil
+          elsif result.failure.span.url == ''
+            'stdin'
           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
-        else
-          raise Sass::ProtocolError, "Unexpected packet received: #{response}"
-        end
-      end
-
-      if response.failure
-        raise Sass::CompilationError.new(
-          response.failure.message,
-          response.failure.formatted,
-          response.failure.span ? response.failure.span.url : nil,
-          response.failure.span ? response.failure.span.start.line + 1 : nil,
-          response.failure.span ? response.failure.span.start.column + 1 : nil,
+            Util.path(result.failure.span.url)
+          end,
+          result.failure.span ? result.failure.span.start.line + 1 : nil,
+          result.failure.span ? result.failure.span.start.column + 1 : nil,
           1
         )
       end
 
-      finish = Sass::Util.now
+      map, source_map = post_process_map(map: result.success.source_map,
+                                         file: file,
+                                         out_file: out_file,
+                                         source_map: source_map,
+                                         source_map_root: source_map_root)
+
+      css = post_process_css(css: result.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 +106,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 one of :space, :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