sass-embedded 0.9.2 → 0.12.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4bb434b577a1d5faadc9e9d9edb6c8ecaa2ded93cb620cd36b219c5b4792236b
-  data.tar.gz: 48b8a5013737d1d4a3fd68155f919538acb3d0d7522d85172ca2476b0dfbfc2e
+  metadata.gz: c66e86f830cc084c0a5a24104a6b6bc9fc0c57bb8fe4e0e52ee15a5b320ecec6
+  data.tar.gz: 1439b6e65bd51f2f589e3dbc62670ea37dc36a365217f69b76e989bf286e62c2
 SHA512:
-  metadata.gz: 0baea25cfe10f0af7dd6c86415bd7a9c9332e32c238fd68877214cb14432d7868645d35315f28b410168380b8c3f7f35a05a747fb258c0ca781d34d28c3fa9b6
-  data.tar.gz: 5eb83255303cd791c51cf86ba1aa49e54d739ee19d045978f5dfd2c46f69d76c27c22f664d845784f226b1ec3a086bc8dc86a7a7c22a091af85df39f50f56147
+  metadata.gz: 7bc51670f5c2cc7cd4edbea3d490d6182ef7d3eb9ebfb800e248dd7a2053828816722f2906c7e41c352821fd79a8ea462e3cf119e2bb6cd3daa05b7e4aa6f0f3
+  data.tar.gz: bb7724417e10a1b4642702cf4f5973647698121e3ea358a4bd3b86b4ea47c07527d4af7338040b75033223132a57e9502356781bd3022f0f0c5fc4f9e02fd26e

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/compile_context.rb

@@ -1,40 +1,62 @@
 # 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
+
+        %i[debug warn].each do |sym|
+          instance_variable_set("@#{sym}".to_sym, get_method(logger, sym))
+        end
+
+        @quiet_deps = quiet_deps
+        @verbose = verbose
 
         super(channel)
 
@@ -52,9 +74,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 +90,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 +110,114 @@ module Sass
 
       private
 
+      def log(event)
+        case event.type
+        when :DEBUG
+          if @debug.nil?
+            Kernel.warn(event.formatted)
+          else
+            @debug.call(event.message, span: Logger::SourceSpan.from_proto(event.span))
+          end
+        when :DEPRECATION_WARNING
+          if @warn.nil?
+            Kernel.warn(event.formatted)
+          else
+            @warn.call(event.message, deprecation: true,
+                                      span: Logger::SourceSpan.from_proto(event.span),
+                                      stack: event.stack_trace)
+          end
+        when :WARNING
+          if @warn.nil?
+            Kernel.warn(event.formatted)
+          else
+            @warn.call(event.message, deprecation: false,
+                                      span: Logger::SourceSpan.from_proto(event.span),
+                                      stack: event.stack_trace)
+          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
+        importer = importer_with_id(canonicalize_request.importer_id)
+        url = get_method(importer, :canonicalize).call canonicalize_request.url,
+                                                       from_import: canonicalize_request.from_import
 
-        if result&.key? :contents
-          @import_responses[url] = EmbeddedProtocol::InboundMessage::ImportResponse.new(
-            id: canonicalize_request.id,
-            success: EmbeddedProtocol::InboundMessage::ImportResponse::ImportSuccess.new(
-              contents: result[:contents],
-              syntax: EmbeddedProtocol::Syntax::SCSS,
-              source_map_url: nil
-            )
-          )
-          EmbeddedProtocol::InboundMessage::CanonicalizeResponse.new(
-            id: canonicalize_request.id,
-            url: url
-          )
-        elsif result&.key? :file
-          canonicalized_url = Util.file_uri_from_path(File.absolute_path(result[:file]))
-
-          # TODO: FileImportRequest is not supported yet.
-          # Workaround by reading contents and return it when server asks
-          @import_responses[canonicalized_url] = EmbeddedProtocol::InboundMessage::ImportResponse.new(
-            id: canonicalize_request.id,
-            success: EmbeddedProtocol::InboundMessage::ImportResponse::ImportSuccess.new(
-              contents: File.read(result[:file]),
-              syntax: EmbeddedProtocol::Syntax::SCSS,
-              source_map_url: nil
-            )
-          )
+        EmbeddedProtocol::InboundMessage::CanonicalizeResponse.new(
+          id: canonicalize_request.id,
+          url: url
+        )
+      rescue StandardError => e
+        EmbeddedProtocol::InboundMessage::CanonicalizeResponse.new(
+          id: canonicalize_request.id,
+          error: e.message
+        )
+      end
 
-          EmbeddedProtocol::InboundMessage::CanonicalizeResponse.new(
-            id: canonicalize_request.id,
-            url: canonicalized_url
-          )
-        else
-          EmbeddedProtocol::InboundMessage::CanonicalizeResponse.new(
-            id: canonicalize_request.id
+      def import_response(import_request)
+        importer = importer_with_id(import_request.importer_id)
+        importer_result = get_method(importer, :load).call import_request.url
+
+        EmbeddedProtocol::InboundMessage::ImportResponse.new(
+          id: import_request.id,
+          success: EmbeddedProtocol::InboundMessage::ImportResponse::ImportSuccess.new(
+            contents: get_attr(importer_result, :contents),
+            syntax: to_proto_syntax(get_attr(importer_result, :syntax)),
+            source_map_url: get_attr(importer_result, :source_map_url)
           )
-        end
+        )
+      rescue StandardError => e
+        EmbeddedProtocol::InboundMessage::ImportResponse.new(
+          id: import_request.id,
+          error: e.message
+        )
       end
 
-      def import_response(import_request)
-        url = import_request.url
+      def file_import_response(file_import_request)
+        file_importer = importer_with_id(file_import_request.importer_id)
+        file_url = get_method(file_importer, :find_file_url).call file_import_request.url,
+                                                                  from_import: file_import_request.from_import
 
-        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
+        raise "file_url must be a file: URL, was \"#{file_url}\"" if !file_url.nil? && !file_url.start_with?('file:')
 
-        @import_responses[url]
+        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,74 +226,93 @@ 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
           EmbeddedProtocol::OutputStyle::COMPRESSED
         else
-          raise ArgumentError, 'output_style must be one of :expanded, :compressed'
+          raise ArgumentError, 'style must be one of :expanded, :compressed'
         end
       end
 
-      def source_map
-        @source_map.is_a?(String) || (@source_map == true && !@out_file.nil?)
-      end
+      def to_proto_importer(importer, id)
+        is_importer = get_method(importer, :canonicalize) && get_method(importer, :load)
+        is_file_importer = get_method(importer, :find_file_url)
 
-      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|
+        if is_importer && !is_file_importer
           EmbeddedProtocol::InboundMessage::CompileRequest::Importer.new(
             importer_id: id
           )
+        elsif is_file_importer && !is_importer
+          EmbeddedProtocol::InboundMessage::CompileRequest::Importer.new(
+            file_importer_id: id
+          )
+        else
+          raise ArgumentError, 'importer must be an Importer or a FileImporter'
+        end
+      end
+
+      def to_proto_importers(importers, load_paths)
+        proto_importers = importers.map.with_index do |importer, id|
+          to_proto_importer(importer, id)
         end
 
-        include_path_importers = @include_paths
-                                 .concat(Embedded.include_paths)
-                                 .map do |include_path|
-          EmbeddedProtocol::InboundMessage::CompileRequest::Importer.new(
-            path: File.absolute_path(include_path)
+        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
+
+      def get_method(obj, sym)
+        sym = sym.to_sym
+        if obj.respond_to? sym
+          obj.method(sym)
+        elsif obj.respond_to? :[]
+          if obj[sym].respond_to? :call
+            obj[sym]
+          elsif obj[sym.to_s].respond_to? :call
+            obj[sym.to_s]
+          end
+        end
+      end
+
+      def get_attr(obj, sym)
+        sym = sym.to_sym
+        if obj.respond_to? sym
+          obj.method(sym).call
+        elsif obj.respond_to? :[]
+          if obj[sym]
+            obj[sym]
+          elsif obj[sym.to_s]
+            obj[sym.to_s]
+          end
+        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.12'
+      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
 

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