sass-embedded 0.9.0 → 0.10.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c5bcaee2299b4f0b9d4d1d23b25773fdad87d1a294a4a34eeec0028d1f89a25c
-  data.tar.gz: 75ce2615300b0d59e73f715ae43007baf09a9818ea56d80b8be4d54b1f561c69
+  metadata.gz: e3c01d861dce5149bb56f25e6cb89e54d21a26bc4e50486298f860b2386198b7
+  data.tar.gz: 36f04488a3118b833f6210766e590a617fe7204dabb31b0908023b32a008ed21
 SHA512:
-  metadata.gz: 93cf20b2df8d4c363797df90e459f52c6dedf5e540cb5b6eb1cd110dded76477adf82f6c0bc0652f1b5201f535265053f7838654952a4bcc7f338bcc69c9464a
-  data.tar.gz: c4190c8fc8e60a37fa834dfdac6fe1842e66d39ac8d0ad9bc1c15ea5c18c16766f19e194be746fc963a5604c740f438c6371aa59c10dd59d452a526fea6cbf0d
+  metadata.gz: c7c15d96579e3dc1843c3dfc66709c9a3ae48bcbb7458f0defcc91c313cffb53dc43b01d114c35b13b8a7b8cfae516440037730283d52e5ea506fffa70a9bcac
+  data.tar.gz: ae089947ade94c0550e9a066860e89e1c774572ddc1ab7c5b42327f4a9f3fe6db41c4422ce96a9454d63b44ae8675091239278ebd8d6f524438c0f680a3e5e26

data/LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2021, なつき
+Copyright (c) 2022, なつき
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/README.md

@@ -16,32 +16,12 @@ gem install sass-embedded
 ## Usage
 
 ``` ruby
-require "sass"
+require 'sass'
 
-Sass.render(file: "style.scss")
+Sass.compile('style.scss')
+Sass.compile_string('h1 { font-size: 40px; }')
 ```
 
-## Options
-
-`Sass.render(**kwargs)` supports the following options:
-
-- [`data`](https://sass-lang.com/documentation/js-api#data)
-- [`file`](https://sass-lang.com/documentation/js-api#file)
-- [`indented_syntax`](https://sass-lang.com/documentation/js-api#indentedsyntax)
-- [`include_paths`](https://sass-lang.com/documentation/js-api#includepaths)
-- [`output_style`](https://sass-lang.com/documentation/js-api#outputstyle)
-- [`indent_type`](https://sass-lang.com/documentation/js-api#indenttype)
-- [`indent_width`](https://sass-lang.com/documentation/js-api#indentwidth)
-- [`linefeed`](https://sass-lang.com/documentation/js-api#linefeed)
-- [`source_map`](https://sass-lang.com/documentation/js-api#sourcemap)
-- [`out_file`](https://sass-lang.com/documentation/js-api#outfile)
-- [`omit_source_map_url`](https://sass-lang.com/documentation/js-api#omitsourcemapurl)
-- [`source_map_contents`](https://sass-lang.com/documentation/js-api#sourcemapcontents)
-- [`source_map_embed`](https://sass-lang.com/documentation/js-api#sourcemapembed)
-- [`source_map_root`](https://sass-lang.com/documentation/js-api#sourcemaproot)
-- [`functions`](https://sass-lang.com/documentation/js-api#functions)
-- [`importer`](https://sass-lang.com/documentation/js-api#importer)
-
 ---
 
 Disclaimer: this is not an official Google product.

data/ext/sass/extconf.rb

@@ -62,9 +62,7 @@ module Sass
         elsif uri.respond_to? :open
           puts "curl -fsSLo #{path} -- #{uri}"
           uri.open do |source|
-            File.open(path, 'wb') do |destination|
-              destination.write source.read
-            end
+            File.binwrite(path, source.read)
           end
         else
           raise

data/lib/sass/compile_error.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require_relative 'logger/source_span'
+
+module Sass
+  # The {CompileError} raised by {Embedded#compile} or {Embedded#compile_string}.
+  class CompileError < StandardError
+    attr_accessor :sass_message, :sass_stack, :span
+
+    def initialize(message, sass_message, sass_stack, span)
+      super(message)
+      @sass_message = sass_message
+      @sass_stack = sass_stack
+      @span = span
+    end
+
+    def self.from_proto(compile_failure)
+      CompileError.new(compile_failure.formatted,
+                       compile_failure.message,
+                       compile_failure.stack_trace,
+                       Logger::SourceSpan.from_proto(compile_failure.span))
+    end
+  end
+end

data/lib/sass/compile_result.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Sass
+  # The {CompileResult} of {Embedded#compile} or {Embedded#compile_string}.
+  class CompileResult
+    attr_reader :css, :source_map, :loaded_urls
+
+    def initialize(css, source_map, loaded_urls)
+      @css = css
+      @source_map = source_map == '' ? nil : source_map
+      @loaded_urls = loaded_urls
+    end
+
+    def self.from_proto(compile_success)
+      CompileResult.new(compile_success.css, compile_success.source_map, compile_success.loaded_urls)
+    end
+  end
+end

data/lib/sass/embedded/channel.rb

@@ -29,7 +29,7 @@ module Sass
         @mutex.synchronize do
           begin
             id = @compiler.add_observer(observer)
-          rescue IOError
+          rescue ProtocolError
             @compiler = Compiler.new
             id = @compiler.add_observer(observer)
           end

data/lib/sass/embedded/compile_context.rb

@@ -1,40 +1,58 @@
 # frozen_string_literal: true
 
 require_relative '../embedded_protocol'
+require_relative '../logger/source_span'
 require_relative 'observer'
-require_relative 'util'
 
 module Sass
   class Embedded
-    # The {Observer} for {Embedded#render}.
+    # The {Observer} for {Embedded#compile}.
     class CompileContext
       include Observer
 
       def initialize(channel,
-                     data:,
-                     file:,
-                     indented_syntax:,
-                     include_paths:,
-                     output_style:,
+                     path:,
+                     source:,
+
+                     importer:,
+                     load_paths:,
+                     syntax:,
+                     url:,
+
                      source_map:,
-                     out_file:,
+                     style:,
+
                      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
+                     importers:,
+
+                     alert_ascii:,
+                     alert_color:,
+                     logger:,
+                     quiet_deps:,
+                     verbose:)
+        @path = path
+        @source = source
+
+        @importer = importer
+        @load_paths = load_paths
+        @syntax = syntax
+        @url = url
+
         @source_map = source_map
-        @out_file = out_file
-        @global_functions = functions.keys
+        @style = style
+
+        @global_functions = functions.keys.map(&:to_s)
+
         @functions = functions.transform_keys do |key|
           key.to_s.split('(')[0].chomp
         end
-        @importer = importer
-        @import_responses = {}
+        @importers = importers
+
+        @alert_ascii = alert_ascii
+        @alert_color = alert_color
+        @logger = logger
+        @quiet_deps = quiet_deps
+        @verbose = verbose
 
         super(channel)
 
@@ -52,9 +70,9 @@ module Sass
             super(nil, message)
           end
         when EmbeddedProtocol::OutboundMessage::LogEvent
-          return unless message.compilation_id == id && $stderr.tty?
+          return unless message.compilation_id == id
 
-          warn message.formatted
+          log message
         when EmbeddedProtocol::OutboundMessage::CanonicalizeRequest
           return unless message.compilation_id == id
 
@@ -68,7 +86,11 @@ module Sass
             send_message import_response message
           end
         when EmbeddedProtocol::OutboundMessage::FileImportRequest
-          raise NotImplementedError, 'FileImportRequest is not implemented'
+          return unless message.compilation_id == id
+
+          Thread.new do
+            send_message file_import_response message
+          end
         when EmbeddedProtocol::OutboundMessage::FunctionCallRequest
           return unless message.compilation_id == id
 
@@ -84,94 +106,107 @@ module Sass
 
       private
 
+      def log(event)
+        case event.type
+        when :DEBUG
+          if @logger.respond_to? :debug
+            @logger.debug(event.message, span: Logger::SourceSpan.from_proto(event.span))
+          else
+            Kernel.warn(event.formatted)
+          end
+        when :DEPRECATION_WARNING
+          if @logger.respond_to? :warn
+            @logger.warn(event.message, deprecation: true, span: Logger::SourceSpan.from_proto(event.span),
+                                        stack: event.stack_trace)
+          else
+            Kernel.warn(event.formatted)
+          end
+        when :WARNING
+          if @logger.respond_to? :warn
+            @logger.warn(event.message, deprecation: false, span: Logger::SourceSpan.from_proto(event.span),
+                                        stack: event.stack_trace)
+          else
+            Kernel.warn(event.formatted)
+          end
+        end
+      end
+
       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'
+          string: unless @source.nil?
+                    EmbeddedProtocol::InboundMessage::CompileRequest::StringInput.new(
+                      source: @source,
+                      url: @url,
+                      syntax: to_proto_syntax(@syntax),
+                      importer: @importer.nil? ? nil : to_proto_importer(@importer, @importers.length)
+                    )
+                  end,
+          path: @path,
+          style: to_proto_output_style(@style),
+          source_map: @source_map,
+          importers: to_proto_importers(@importers, @load_paths),
+          global_functions: @global_functions,
+          alert_ascii: @alert_ascii,
+          alert_color: @alert_color
         )
       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
-            )
-          )
+        url = importer_with_id(canonicalize_request.importer_id).canonicalize canonicalize_request.url
 
-          EmbeddedProtocol::InboundMessage::CanonicalizeResponse.new(
-            id: canonicalize_request.id,
-            url: canonicalized_url
-          )
-        else
-          EmbeddedProtocol::InboundMessage::CanonicalizeResponse.new(
-            id: canonicalize_request.id
-          )
-        end
+        EmbeddedProtocol::InboundMessage::CanonicalizeResponse.new(
+          id: canonicalize_request.id,
+          url: url
+        )
+      rescue StandardError => e
+        EmbeddedProtocol::InboundMessage::CanonicalizeResponse.new(
+          id: canonicalize_request.id,
+          error: e.message
+        )
       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}"
+        importer_result = importer_with_id(import_request.importer_id).load import_request.url
+
+        EmbeddedProtocol::InboundMessage::ImportResponse.new(
+          id: import_request.id,
+          success: EmbeddedProtocol::InboundMessage::ImportResponse::ImportSuccess.new(
+            contents: importer_result.contents,
+            syntax: to_proto_syntax(importer_result.syntax),
+            source_map_url: importer_result.source_map_url
           )
-        end
+        )
+      rescue StandardError => e
+        EmbeddedProtocol::InboundMessage::ImportResponse.new(
+          id: import_request.id,
+          error: e.message
+        )
+      end
 
-        @import_responses[url]
+      def file_import_response(file_import_request)
+        file_importer = importer_with_id(file_import_request.importer_id)
+        file_url = file_importer.find_file_url file_import_request.url,
+                                               from_import: file_import_request.from_import
+
+        EmbeddedProtocol::InboundMessage::FileImportResponse.new(
+          id: file_import_request.id,
+          file_url: file_url
+        )
+      rescue StandardError => e
+        EmbeddedProtocol::InboundMessage::FileImportResponse.new(
+          id: file_import_request.id,
+          error: e.message
+        )
       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 }
+          .filter { |argument| argument.value == :argument_list }
+          .map { |argument| argument.argument_list.id }
         )
       rescue StandardError => e
         EmbeddedProtocol::InboundMessage::FunctionCallResponse.new(
@@ -180,36 +215,21 @@ module Sass
         )
       end
 
-      def syntax
-        if @indented_syntax == true
+      def to_proto_syntax(syntax)
+        case syntax&.to_sym
+        when :scss
+          EmbeddedProtocol::Syntax::SCSS
+        when :indented
           EmbeddedProtocol::Syntax::INDENTED
+        when :css
+          EmbeddedProtocol::Syntax::CSS
         else
-          EmbeddedProtocol::Syntax::SCSS
+          raise ArgumentError, 'syntax must be one of :scss, :indented, :css'
         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
+      def to_proto_output_style(style)
+        case style&.to_sym
         when :expanded
           EmbeddedProtocol::OutputStyle::EXPANDED
         when :compressed
@@ -219,35 +239,40 @@ module Sass
         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|
+      def to_proto_importer(importer, id)
+        if importer.respond_to?(:canonicalize) && importer.respond_to?(:load)
           EmbeddedProtocol::InboundMessage::CompileRequest::Importer.new(
             importer_id: id
           )
+        elsif importer.respond_to?(:find_file_url)
+          EmbeddedProtocol::InboundMessage::CompileRequest::Importer.new(
+            file_importer_id: id
+          )
+        else
+          raise ArgumentError, 'importer must be an Importer or a FileImporter'
         end
+      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)
+      def to_proto_importers(importers, load_paths)
+        proto_importers = importers.map.with_index do |importer, id|
+          to_proto_importer(importer, id)
+        end
+
+        load_paths.each do |load_path|
+          proto_importers << EmbeddedProtocol::InboundMessage::CompileRequest::Importer.new(
+            path: File.absolute_path(load_path)
           )
         end
 
-        custom_importers.concat include_path_importers
+        proto_importers
+      end
+
+      def importer_with_id(id)
+        if id == @importers.length
+          @importer
+        else
+          @importers[id]
+        end
       end
     end
   end

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

@@ -3,7 +3,7 @@
 module Sass
   class Embedded
     class Compiler
-      REQUIREMENTS = '~> 1.0.0-beta.11'
+      REQUIREMENTS = '~> 1.0.0-beta.16'
     end
   end
 end

data/lib/sass/embedded/compiler.rb

@@ -4,7 +4,7 @@ require 'observer'
 require 'open3'
 require_relative '../embedded_protocol'
 require_relative 'compiler/path'
-require_relative 'error'
+require_relative 'protocol_error'
 
 module Sass
   class Embedded
@@ -17,9 +17,9 @@ module Sass
       ONEOF_MESSAGE = EmbeddedProtocol::InboundMessage
                       .descriptor
                       .lookup_oneof('message')
-                      .collect do |field_descriptor|
+                      .to_h do |field_descriptor|
         [field_descriptor.subtype, field_descriptor.name]
-      end.to_h
+      end
 
       private_constant :ONEOF_MESSAGE
 
@@ -41,7 +41,7 @@ module Sass
 
       def add_observer(*args)
         @observerable_mutex.synchronize do
-          raise IOError, 'half-closed compiler' if half_closed?
+          raise ProtocolError, 'half-closed compiler' if half_closed?
 
           super(*args)
 

data/lib/sass/embedded/observer.rb

@@ -25,6 +25,7 @@ module Sass
 
       def update(error, message)
         @subscription.unsubscribe
+
         @mutex.synchronize do
           @error = error
           @message = message

data/lib/sass/embedded/protocol_error.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Sass
+  class Embedded
+    class ProtocolError < StandardError; end
+  end
+end