sassc-embedded 1.63.0 → 1.78.0

data/lib/sassc/embedded.rb

@@ -3,7 +3,6 @@
 require 'sassc'
 require 'sass-embedded'
 
-require 'base64'
 require 'json'
 require 'uri'
 
@@ -11,14 +10,16 @@ require_relative 'embedded/version'
 
 module SassC
   class Engine
+    remove_method(:render) if public_method_defined?(:render, false)
+
     def render
       return @template.dup if @template.empty?
 
       result = ::Sass.compile_string(
         @template,
-        importer: import_handler.setup(nil),
-        load_paths: load_paths,
-        syntax: syntax,
+        importer: (NoopImporter unless @options[:importer].nil?),
+        load_paths:,
+        syntax:,
         url: file_url,
 
         charset: @options.fetch(:charset, true),
@@ -27,28 +28,28 @@ module SassC
         style: output_style,
 
         functions: functions_handler.setup(nil, functions: @functions),
-        importers: @options.fetch(:importers, []),
+        importers: import_handler.setup(nil).concat(@options.fetch(:importers, [])),
 
         alert_ascii: @options.fetch(:alert_ascii, false),
         alert_color: @options.fetch(:alert_color, nil),
-        logger: @options.fetch(:logger, nil),
+        fatal_deprecations: @options.fetch(:fatal_deprecations, []),
+        future_deprecations: @options.fetch(:future_deprecations, []),
+        logger: quiet? ? ::Sass::Logger.silent : @options.fetch(:logger, nil),
         quiet_deps: @options.fetch(:quiet_deps, false),
+        silence_deprecations: @options.fetch(:silence_deprecations, []),
         verbose: @options.fetch(:verbose, false)
       )
 
       @loaded_urls = result.loaded_urls
       @source_map = result.source_map
 
-      return if quiet?
-
       css = result.css
       css += "\n" unless css.empty?
       unless @source_map.nil? || omit_source_map_url?
-        url = URL.parse(output_url || file_url)
         source_mapping_url = if source_map_embed?
-                               "data:application/json;base64,#{Base64.strict_encode64(@source_map)}"
+                               "data:application/json;base64,#{[@source_map].pack('m0')}"
                              else
-                               URL.parse(source_map_file_url).route_from(url).to_s
+                               Uri.file_urls_to_relative_url(source_map_file_url, file_url)
                              end
         css += "\n/*# sourceMappingURL=#{source_mapping_url} */"
       end
@@ -59,27 +60,30 @@ module SassC
       line = e.span&.start&.line
       line += 1 unless line.nil?
       url = e.span&.url
-      path = (URL.parse(url).route_from(URL.path_to_file_url("#{Dir.pwd}/")) if url&.start_with?(Protocol::FILE))
-      raise SyntaxError.new(e.full_message, filename: path, line: line)
+      path = (Uri.file_urls_to_relative_path(url, Uri.path_to_file_url("#{Dir.pwd}/")) if url&.start_with?('file:'))
+      raise SyntaxError.new(e.full_message, filename: path, line:)
     end
 
+    remove_method(:dependencies) if public_method_defined?(:dependencies, false)
+
     def dependencies
       raise NotRenderedError unless @loaded_urls
 
-      Dependency.from_filenames(@loaded_urls
-        .filter { |url| url.start_with?(Protocol::FILE) && url != file_url }
-        .map { |url| URL.file_url_to_path(url) })
+      Dependency.from_filenames(@loaded_urls.filter_map do |url|
+        Uri.file_url_to_path(url) if url.start_with?('file:') && !url.include?('?') && url != file_url
+      end)
     end
 
+    remove_method(:source_map) if public_method_defined?(:source_map, false)
+
     def source_map
       raise NotRenderedError unless @source_map
 
-      url = URL.parse(source_map_file_url || file_url)
+      url = Uri.parse(source_map_file_url || file_url)
       data = JSON.parse(@source_map)
-      data['file'] = URL.parse(output_url).route_from(url).to_s if output_url
       data['sources'].map! do |source|
-        if source.start_with?(Protocol::FILE)
-          URL.parse(source).route_from(url).to_s
+        if source.start_with?('file:')
+          Uri.file_urls_to_relative_url(source, url)
         else
           source
         end
@@ -91,35 +95,29 @@ module SassC
     private
 
     def file_url
-      @file_url ||= URL.path_to_file_url(File.absolute_path(filename || 'stdin'))
-    end
-
-    def output_path
-      @output_path ||= @options.fetch(:output_path) do
-        "#{filename.delete_suffix(File.extname(filename))}.css" if filename
-      end
-    end
-
-    def output_url
-      @output_url ||= (URL.path_to_file_url(File.absolute_path(output_path)) if output_path)
+      @file_url ||= Uri.path_to_file_url(File.absolute_path(filename || 'stdin'))
     end
 
     def source_map_file_url
-      @source_map_file_url ||= (URL.path_to_file_url(File.absolute_path(source_map_file)) if source_map_file)
+      @source_map_file_url ||= if source_map_file
+                                 Uri.path_to_file_url(File.absolute_path(source_map_file))
+                                    .gsub('%3F', '?') # https://github.com/sass-contrib/sassc-embedded-shim-ruby/pull/69
+                               end
     end
 
+    remove_method(:output_style) if private_method_defined?(:output_style, false)
+
     def output_style
       @output_style ||= begin
-        style = @options.fetch(:style, :sass_style_nested).to_s
-        style = "sass_style_#{style}" unless style.start_with?('sass_style_')
-        raise InvalidStyleError unless OUTPUT_STYLES.include?(style.to_sym)
+        style = @options.fetch(:style, :sass_style_nested).to_s.delete_prefix('sass_style_').to_sym
 
-        style = style.delete_prefix('sass_style_').to_sym
         case style
-        when :nested, :compact
+        when :nested, :compact, :expanded
           :expanded
+        when :compressed
+          :compressed
         else
-          style
+          raise InvalidStyleError
         end
       end
     end
@@ -130,16 +128,16 @@ module SassC
       syntax
     end
 
+    remove_method(:load_paths) if private_method_defined?(:load_paths, false)
+
     def load_paths
-      @load_paths ||= if @options[:importer].nil?
-                        (@options[:load_paths] || []) + SassC.load_paths
-                      else
-                        []
-                      end
+      @load_paths ||= (@options[:load_paths] || []) + SassC.load_paths
     end
   end
 
   class FunctionsHandler
+    remove_method(:setup) if public_method_defined?(:setup, false)
+
     def setup(_native_options, functions: Script::Functions)
       @callbacks = {}
 
@@ -150,7 +148,7 @@ module SassC
       end.new
       functions_wrapper.options = @options
 
-      Script.custom_functions(functions: functions).each do |custom_function|
+      Script.custom_functions(functions:).each do |custom_function|
         callback = lambda do |native_argument_list|
           function_arguments = arguments_from_native_list(native_argument_list)
           begin
@@ -164,7 +162,7 @@ module SassC
           raise e
         end
 
-        @callbacks[Script.formatted_function_name(custom_function, functions: functions)] = callback
+        @callbacks[Script.formatted_function_name(custom_function, functions:)] = callback
       end
 
       @callbacks
@@ -172,40 +170,66 @@ module SassC
 
     private
 
+    remove_method(:arguments_from_native_list) if private_method_defined?(:arguments_from_native_list, false)
+
     def arguments_from_native_list(native_argument_list)
       native_argument_list.filter_map do |native_value|
         Script::ValueConversion.from_native(native_value, @options)
       end
     end
+  end
 
-    begin
-      begin
-        raise RuntimeError
-      rescue StandardError
-        raise ::Sass::ScriptError
-      end
-    rescue StandardError => e
-      unless e.full_message.include?(e.cause.full_message)
-        ::Sass::ScriptError.class_eval do
-          def full_message(...)
-            full_message = super(...)
-            if cause
-              "#{full_message}\n#{cause.full_message(...)}"
-            else
-              full_message
-            end
-          end
-        end
-      end
-    end
+  module NoopImporter
+    module_function
+
+    def canonicalize(...); end
+
+    def load(...); end
   end
 
+  private_constant :NoopImporter
+
   class ImportHandler
+    remove_method(:setup) if public_method_defined?(:setup, false)
+
     def setup(_native_options)
-      Importer.new(@importer) if @importer
+      if @importer
+        import_cache = ImportCache.new(@importer)
+        [Importer.new(import_cache), FileImporter.new(import_cache)]
+      else
+        []
+      end
     end
 
+    class Importer
+      def initialize(import_cache)
+        @import_cache = import_cache
+      end
+
+      def canonicalize(...)
+        @import_cache.canonicalize(...)
+      end
+
+      def load(...)
+        @import_cache.load(...)
+      end
+    end
+
+    private_constant :Importer
+
     class FileImporter
+      def initialize(import_cache)
+        @import_cache = import_cache
+      end
+
+      def find_file_url(...)
+        @import_cache.find_file_url(...)
+      end
+    end
+
+    private_constant :FileImporter
+
+    module FileSystemImporter
       class << self
         def resolve_path(path, from_import)
           ext = File.extname(path)
@@ -217,15 +241,6 @@ module SassC
             return exactly_one(try_path(path))
           end
 
-          unless ext.empty?
-            if from_import
-              result = exactly_one(try_path("#{without_ext(path)}.import#{ext}"))
-              return result unless result.nil?
-            end
-            result = exactly_one(try_path(path))
-            return result unless result.nil?
-          end
-
           if from_import
             result = exactly_one(try_path_with_ext("#{path}.import"))
             return result unless result.nil?
@@ -253,7 +268,7 @@ module SassC
         end
 
         def try_path_as_dir(path, from_import)
-          return unless dir_exist? path
+          return unless dir_exist?(path)
 
           if from_import
             result = exactly_one(try_path_with_ext(File.join(path, 'index.import')))
@@ -265,7 +280,7 @@ module SassC
 
         def exactly_one(paths)
           return if paths.empty?
-          return paths.first if paths.length == 1
+          return paths.first if paths.one?
 
           raise "It's not clear which file to import. Found:\n#{paths.map { |path| "  #{path}" }.join("\n")}"
         end
@@ -285,79 +300,63 @@ module SassC
       end
     end
 
-    private_constant :FileImporter
+    private_constant :FileSystemImporter
 
-    class Importer
+    class ImportCache
       def initialize(importer)
         @importer = importer
-
-        @canonical_urls = {}
-        @id = 0
         @importer_results = {}
-        @parent_urls = [URL.path_to_file_url(File.absolute_path(@importer.options[:filename] || 'stdin'))]
+        @importer_result = nil
+        @file_url = nil
       end
 
-      def canonicalize(url, from_import:)
-        if url.start_with?(Protocol::IMPORT)
-          canonical_url = @canonical_urls.delete(url.delete_prefix(Protocol::IMPORT))
+      def canonicalize(url, context)
+        return unless context.containing_url&.start_with?('file:')
+
+        containing_url = context.containing_url
+
+        path = Uri.decode_uri_component(url)
+        parent_path = Uri.file_url_to_path(containing_url)
+        parent_dir = File.dirname(parent_path)
+
+        if containing_url.include?('?')
+          canonical_url = Uri.path_to_file_url(File.absolute_path(path, parent_dir))
           unless @importer_results.key?(canonical_url)
-            canonical_url = resolve_file_url(canonical_url, @parent_urls.last, from_import)
+            @file_url = resolve_file_url(path, parent_dir, context.from_import)
+            return
           end
-          @parent_urls.push(canonical_url)
-          canonical_url
-        elsif url.start_with?(Protocol::FILE)
-          path = URL.parse(url).route_from(@parent_urls.last).to_s
-          parent_path = URL.file_url_to_path(@parent_urls.last)
-
-          imports = @importer.imports(path, parent_path)
-          imports = [SassC::Importer::Import.new(path)] if imports.nil?
-          imports = [imports] unless imports.is_a?(Array)
-          imports.each do |import|
-            import.path = File.absolute_path(import.path, File.dirname(parent_path))
+        else
+          imports = [*@importer.imports(path, parent_path)]
+          canonical_url = imports_to_native(imports, parent_dir, context.from_import, url, containing_url)
+          unless @importer_results.key?(canonical_url)
+            @file_url = canonical_url
+            return
           end
-
-          canonical_url = "#{Protocol::IMPORT}#{next_id}"
-          @importer_results[canonical_url] = imports_to_native(imports)
-          canonical_url
-        elsif url.start_with?(Protocol::LOADED)
-          canonical_url = Protocol::LOADED
-          @parent_urls.pop
-          canonical_url
         end
+
+        @importer_result = @importer_results.delete(canonical_url)
+        canonical_url
       end
 
-      def load(canonical_url)
-        if @importer_results.key?(canonical_url)
-          @importer_results.delete(canonical_url)
-        elsif canonical_url.start_with?(Protocol::FILE)
-          path = URL.file_url_to_path(canonical_url)
-          {
-            contents: File.read(path),
-            syntax: syntax(path),
-            source_map_url: canonical_url
-          }
-        elsif canonical_url.start_with?(Protocol::LOADED)
-          {
-            contents: '',
-            syntax: :scss
-          }
-        end
+      def load(_canonical_url)
+        importer_result = @importer_result
+        @importer_result = nil
+        importer_result
       end
 
-      private
+      def find_file_url(_url, context)
+        return if context.containing_url.nil? || @file_url.nil?
 
-      def load_paths
-        @load_paths ||= (@importer.options[:load_paths] || []) + SassC.load_paths
+        canonical_url = @file_url
+        @file_url = nil
+        canonical_url
       end
 
-      def resolve_file_url(url, parent_url, from_import)
-        path = URL.parse(url).route_from(parent_url).to_s
-        parent_path = URL.file_url_to_path(parent_url)
-        [File.dirname(parent_path)].concat(load_paths).each do |load_path|
-          resolved = FileImporter.resolve_path(File.absolute_path(path, load_path), from_import)
-          return URL.path_to_file_url(resolved) unless resolved.nil?
-        end
-        nil
+      private
+
+      def resolve_file_url(path, parent_dir, from_import)
+        resolved = FileSystemImporter.resolve_path(File.absolute_path(path, parent_dir), from_import)
+        Uri.path_to_file_url(resolved) unless resolved.nil?
       end
 
       def syntax(path)
@@ -371,47 +370,55 @@ module SassC
         end
       end
 
-      def imports_to_native(imports)
-        {
+      def import_to_native(import, parent_dir, from_import, canonicalize)
+        if import.source
+          canonical_url = Uri.path_to_file_url(File.absolute_path(import.path, parent_dir))
+          @importer_results[canonical_url] = if import.source.is_a?(Hash)
+                                               {
+                                                 contents: import.source[:contents],
+                                                 syntax: import.source[:syntax],
+                                                 source_map_url: canonical_url
+                                               }
+                                             else
+                                               {
+                                                 contents: import.source,
+                                                 syntax: syntax(import.path),
+                                                 source_map_url: canonical_url
+                                               }
+                                             end
+          return canonical_url if canonicalize
+        elsif canonicalize
+          return resolve_file_url(import.path, parent_dir, from_import)
+        end
+
+        Uri.encode_uri_path_component(import.path)
+      end
+
+      def imports_to_native(imports, parent_dir, from_import, url, containing_url)
+        return import_to_native(imports.first, parent_dir, from_import, true) if imports.one?
+
+        canonical_url = "#{containing_url}?url=#{Uri.encode_uri_query_component(url)}&from_import=#{from_import}"
+        @importer_results[canonical_url] = {
           contents: imports.flat_map do |import|
-            id = next_id
-            canonical_url = URL.path_to_file_url(import.path)
-            @canonical_urls[id] = canonical_url
-            if import.source
-              @importer_results[canonical_url] = if import.source.is_a?(Hash)
-                                                   {
-                                                     contents: import.source[:contents],
-                                                     syntax: import.source[:syntax],
-                                                     source_map_url: canonical_url
-                                                   }
-                                                 else
-                                                   {
-                                                     contents: import.source,
-                                                     syntax: syntax(import.path),
-                                                     source_map_url: canonical_url
-                                                   }
-                                                 end
-            end
-            [
-              "@import \"#{Protocol::IMPORT}#{id}\";",
-              "@import \"#{Protocol::LOADED}#{id}\";"
-            ]
+            at_rule = from_import ? '@import' : '@forward'
+            url = import_to_native(import, parent_dir, from_import, false)
+            "#{at_rule} #{Script::Value::String.quote(url)};"
           end.join("\n"),
           syntax: :scss
         }
-      end
 
-      def next_id
-        id = @id
-        @id = id.next
-        id.to_s
+        canonical_url
       end
     end
 
-    private_constant :Importer
+    private_constant :ImportCache
   end
 
   class Sass2Scss
+    class << self
+      remove_method(:convert) if public_method_defined?(:convert, false)
+    end
+
     def self.convert(sass)
       {
         contents: sass,
@@ -421,7 +428,38 @@ module SassC
   end
 
   module Script
+    class Value
+      class String
+        class << self
+          remove_method(:quote) if public_method_defined?(:quote, false)
+        end
+
+        # Returns the quoted string representation of `contents`.
+        #
+        # @options opts :quote [String]
+        #   The preferred quote style for quoted strings. If `:none`, strings are
+        #   always emitted unquoted. If `nil`, quoting is determined automatically.
+        # @options opts :sass [String]
+        #   Whether to quote strings for Sass source, as opposed to CSS. Defaults to `false`.
+        def self.quote(contents, opts = {})
+          contents = ::Sass::Value::String.new(contents, quoted: opts[:quote] != :none).to_s
+          opts[:sass] ? contents.gsub('#', '\#') : contents
+        end
+
+        remove_method(:to_s) if public_method_defined?(:to_s, false)
+
+        def to_s(opts = {})
+          opts = { quote: :none }.merge!(opts) if @type == :identifier
+          self.class.quote(@value, opts)
+        end
+      end
+    end
+
     module ValueConversion
+      class << self
+        remove_method(:from_native) if public_method_defined?(:from_native, false)
+      end
+
       def self.from_native(value, options)
         case value
         when ::Sass::Value::Null::NULL
@@ -477,6 +515,10 @@ module SassC
         end
       end
 
+      class << self
+        remove_method(:to_native) if public_method_defined?(:to_native, false)
+      end
+
       def self.to_native(value)
         case value
         when nil
@@ -537,48 +579,84 @@ module SassC
     end
   end
 
-  module Protocol
-    FILE = 'file:'
-    IMPORT = 'sassc-embedded-import:'
-    LOADED = 'sassc-embedded-loaded:'
-  end
+  module Uri
+    module_function
 
-  private_constant :Protocol
+    def parse(...)
+      ::URI::RFC3986_PARSER.parse(...)
+    end
 
-  module URL
-    PARSER = URI::Parser.new({ RESERVED: ';/?:@&=+$,' })
+    encode_uri_hash = {}
+    decode_uri_hash = {}
+    256.times do |i|
+      c = -[i].pack('C')
+      h = c.unpack1('H')
+      l = c.unpack1('h')
+      pdd = -"%#{h}#{l}"
+      pdu = -"%#{h}#{l.upcase}"
+      pud = -"%#{h.upcase}#{l}"
+      puu = -pdd.upcase
+      encode_uri_hash[c] = puu
+      decode_uri_hash[pdd] = c
+      decode_uri_hash[pdu] = c
+      decode_uri_hash[pud] = c
+      decode_uri_hash[puu] = c
+    end.freeze
+    encode_uri_hash.freeze
+    decode_uri_hash.freeze
+
+    {
+      uri_path_component: "!$&'()*+,;=:/@",
+      uri_query_component: "!$&'()*+,;=:/?@",
+      uri_component: nil,
+      uri: "!$&'()*+,;=:/?#[]@"
+    }
+      .each do |symbol, unescaped|
+        encode_regexp = Regexp.new("[^0-9A-Za-z#{Regexp.escape("-._~#{unescaped}")}]", Regexp::NOENCODING)
+
+        define_method(:"encode_#{symbol}") do |str|
+          str.b.gsub(encode_regexp, encode_uri_hash).force_encoding(str.encoding)
+        end
 
-    private_constant :PARSER
+        next if symbol.match?(/_.+_/o)
 
-    module_function
+        decode_regexp = /%[0-9A-Fa-f]{2}/o
+        decode_uri_hash_with_preserve_escaped = if unescaped.nil? || unescaped.empty?
+                                                  decode_uri_hash
+                                                else
+                                                  decode_uri_hash.to_h do |key, value|
+                                                    [key, unescaped.include?(value) ? key : value]
+                                                  end.freeze
+                                                end
 
-    def parse(str)
-      PARSER.parse(str)
-    end
+        define_method(:"decode_#{symbol}") do |str|
+          str.gsub(decode_regexp, decode_uri_hash_with_preserve_escaped).force_encoding(str.encoding)
+        end
+      end
 
-    def escape(str)
-      PARSER.escape(str)
+    def file_urls_to_relative_url(url, from_url)
+      parse(url).route_from(from_url).to_s
     end
 
-    def unescape(str)
-      PARSER.unescape(str)
+    def file_urls_to_relative_path(url, from_url)
+      decode_uri_component(file_urls_to_relative_url(url, from_url))
     end
 
     def file_url_to_path(url)
-      return if url.nil?
-
-      path = unescape(parse(url).path)
-      path = path[1..] if Gem.win_platform? && path[0].chr == '/' && path[1].chr =~ /[a-z]/i && path[2].chr == ':'
+      path = decode_uri_component(parse(url).path)
+      if path.start_with?('/')
+        windows_path = path[1..]
+        path = windows_path if File.absolute_path?(windows_path)
+      end
       path
     end
 
     def path_to_file_url(path)
-      return if path.nil?
-
       path = "/#{path}" unless path.start_with?('/')
-      URI::File.build([nil, escape(path)]).to_s
+
+      "file://#{encode_uri_path_component(path)}"
     end
   end
 
-  private_constant :URL
+  private_constant :Uri
 end