sassc-embedded 1.2.0 → 1.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 165d1e520918392a01a808a20da523f4f573d762684c279f83dcf75202659c46
-  data.tar.gz: 80bf5a80e154a4be31c013489bd807a7c8ffdac4ffc1f143baf76c81e61326f0
+  metadata.gz: 2c93f068bcc4406780bad76da750f2b265943a971456d3b56a14b0bdb2f0be8a
+  data.tar.gz: c851519ef1b2f08fe4370f4669b9df263b7264844911df873de30273748b4675
 SHA512:
-  metadata.gz: f5f88d175f876435912bbb8141180dd4c72f3874b3d76604188598499c53c9dcdc5f273e3abdaff8674c93de30553a4be9370ba1b6665bab38a578cc3540ef65
-  data.tar.gz: 6c26f72589706937100230aa6e7e5e2ddd687f7cead7ce6653354fd556f371e26a07a400012845210c947f2928532ffb0a13c01ecde27b8b4a4eb5c691ec6e32
+  metadata.gz: 14f22ec99ba45f9fddf083a1bccab5b34b3c48e745cfd30c53078c504d90d3e870c27effc1c9ae20b32ead54602dffadfa48b59993a61fa82991c9cafa1cd856
+  data.tar.gz: 6a1d3fde2932a3c83932bb6601ad7e5ac0d945d69f69d0d5acf36c378401afdd3cbc7cb00dcb835b10be697fdbdb378bbcffd1e957e2995e686f3d10f546c6b7

data/README.md

@@ -51,6 +51,4 @@ See [rubydoc.info/gems/sassc](https://rubydoc.info/gems/sassc) for full API docu
 
 4. Option `:line_comments` is ignored.
 
-5. Argument `parent_path` in `Importer#imports(path, parent_path)` is set to value of option `:filename`.
-
 See [the dart-sass documentation](https://github.com/sass/dart-sass#behavioral-differences-from-ruby-sass) for other differences.

data/lib/sassc/embedded/version.rb

@@ -2,6 +2,6 @@
 
 module SassC
   module Embedded
-    VERSION = '1.2.0'
+    VERSION = '1.4.0'
   end
 end

data/lib/sassc/embedded.rb

@@ -17,7 +17,7 @@ module SassC
 
       result = ::Sass.compile_string(
         @template,
-        importer: nil,
+        importer: import_handler.setup(nil),
         load_paths: load_paths,
         syntax: syntax,
         url: file_url,
@@ -26,8 +26,8 @@ module SassC
         source_map_include_sources: source_map_contents?,
         style: output_style,
 
-        functions: FunctionsHandler.new(@options).setup(nil, functions: @functions),
-        importers: ImportHandler.new(@options).setup(nil),
+        functions: functions_handler.setup(nil, functions: @functions),
+        importers: [],
 
         alert_ascii: @options.fetch(:alert_ascii, false),
         alert_color: @options.fetch(:alert_color, nil),
@@ -45,30 +45,25 @@ module SassC
     rescue ::Sass::CompileError => e
       line = e.span&.start&.line
       line += 1 unless line.nil?
-      path = URL.file_url_to_path(e.span&.url)
+      url = e.span&.url
+      path = url&.start_with?('file:') ? URL.file_url_to_path(url) : nil
       path = relative_path(Dir.pwd, path) unless path.nil?
       raise SyntaxError.new(e.message, filename: path, line: line)
     end
 
     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,
-        ("#{File.basename(filename, File.extname(filename))}.css" if filename)
+        ("#{filename.delete_suffix(File.extname(filename))}.css" if filename)
       )
     end
 
-    def file_url
-      @file_url ||= URL.path_to_file_url(filename || 'stdin')
-    end
-
-    def syntax
-      syntax = @options.fetch(:syntax, :scss)
-      syntax = :indented if syntax.to_sym == :sass
-      syntax
-    end
-
     def output_style
       @output_style ||= begin
         style = @options.fetch(:style, :sass_style_nested).to_s
@@ -87,8 +82,18 @@ module SassC
       end
     end
 
+    def syntax
+      syntax = @options.fetch(:syntax, :scss)
+      syntax = :indented if syntax.to_sym == :sass
+      syntax
+    end
+
     def load_paths
-      @load_paths ||= (@options[:load_paths] || []) + SassC.load_paths
+      @load_paths ||= if @options[:importer].nil?
+                        (@options[:load_paths] || []) + SassC.load_paths
+                      else
+                        []
+                      end
     end
 
     def post_process_source_map(source_map)
@@ -192,92 +197,218 @@ module SassC
 
   class ImportHandler
     def setup(_native_options)
-      if @importer
-        [FileImporter.new, Importer.new(@importer)]
-      else
-        []
-      end
+      Importer.new(@importer) if @importer
     end
 
     class FileImporter
-      def find_file_url(url, **)
-        return url if url.start_with?('file:')
+      class << self
+        def resolve_path(path, from_import)
+          ext = File.extname(path)
+          unless ext.empty?
+            if from_import
+              result = exactly_one(try_path("#{without_ext(path)}.import#{ext}"))
+              return result unless result.nil?
+            end
+            return exactly_one(try_path(path))
+          end
+
+          if from_import
+            result = exactly_one(try_path_with_ext("#{path}.import"))
+            return result unless result.nil?
+          end
+
+          result = exactly_one(try_path_with_ext(path))
+          return result unless result.nil?
+
+          try_path_as_dir(path, from_import)
+        end
+
+        private
+
+        def try_path_with_ext(path)
+          result = try_path("#{path}.sass") + try_path("#{path}.scss")
+          result.empty? ? try_path("#{path}.css") : result
+        end
+
+        def try_path(path)
+          partial = File.join(File.dirname(path), "_#{File.basename(path)}")
+          result = []
+          result.push(partial) if file_exist?(partial)
+          result.push(path) if file_exist?(path)
+          result
+        end
+
+        def try_path_as_dir(path, from_import)
+          return unless dir_exist? path
+
+          if from_import
+            result = exactly_one(try_path_with_ext(File.join(path, 'index.import')))
+            return result unless result.nil?
+          end
+
+          exactly_one(try_path_with_ext(File.join(path, 'index')))
+        end
+
+        def exactly_one(paths)
+          return if paths.empty?
+          return paths.first if paths.length == 1
+
+          raise "It's not clear which file to import. Found:\n#{paths.map { |path| "  #{path}" }.join("\n")}"
+        end
+
+        def file_exist?(path)
+          File.exist?(path) && File.file?(path)
+        end
+
+        def dir_exist?(path)
+          File.exist?(path) && File.directory?(path)
+        end
+
+        def without_ext(path)
+          ext = File.extname(path)
+          path.delete_suffix(ext)
+        end
       end
     end
 
     private_constant :FileImporter
 
     class Importer
+      module Protocol
+        FILE = 'file:'
+        IMPORT = 'sassc-embedded-import:'
+        LOAD = 'sassc-embedded-load:'
+        LOADED = 'sassc-embedded-loaded:'
+      end
+
+      private_constant :Protocol
+
       def initialize(importer)
         @importer = importer
         @importer_results = {}
+        @parent_urls = [URL.path_to_file_url(File.absolute_path(@importer.options[:filename] || 'stdin'))]
       end
 
-      def canonicalize(url, **)
-        path = if url.start_with?('file:')
-                 URL.file_url_to_path(url)
-               else
-                 URL.unescape(url)
-               end
-        canonical_url = URL.path_to_file_url(File.absolute_path(path))
+      def canonicalize(url, from_import:)
+        return url if url.start_with?(Protocol::IMPORT, Protocol::LOADED)
 
-        if @importer_results.key?(canonical_url)
-          return if @importer_results[canonical_url].nil?
+        if url.start_with?(Protocol::LOAD)
+          url = url.delete_prefix(Protocol::LOAD)
+          return url if @importer_results.key?(url)
 
-          return canonical_url
+          path = URL.parse(url).route_from(@parent_urls.last).to_s
+          resolved = resolve_path(path, URL.file_url_to_path(@parent_urls.last.to_s), from_import)
+          return resolved.nil? ? nil : URL.path_to_file_url(resolved)
         end
 
-        canonical_url = "sassc-embedded:#{canonical_url}"
+        return unless url.start_with?(Protocol::FILE)
 
-        imports = @importer.imports(path, @importer.options[:filename])
-        unless imports.is_a?(Array)
-          return if imports.path == path
+        path = URL.parse(url).route_from(@parent_urls.last).to_s
+        parent_path = URL.file_url_to_path(@parent_urls.last)
 
-          imports = [imports]
+        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))
         end
 
-        dirname = File.dirname(@importer.options.fetch(:filename, 'stdin'))
-        contents = imports.map do |import|
-          import_url = URL.path_to_file_url(File.absolute_path(import.path, dirname))
-          @importer_results[import_url] = if import.source
-                                            {
-                                              contents: import.source,
-                                              syntax: case import.path
-                                                      when /\.sass$/i
-                                                        :indented
-                                                      when /\.css$/i
-                                                        :css
-                                                      else
-                                                        :scss
-                                                      end,
-                                              source_map_url: if import.source_map_path
-                                                                URL.path_to_file_url(
-                                                                  File.absolute_path(
-                                                                    import.source_map_path, dirname
-                                                                  )
-                                                                )
-                                                              end
-                                            }
-                                          end
-          "@import #{import_url.inspect};"
-        end.join("\n")
-
-        @importer_results[canonical_url] = {
-          contents: contents,
-          syntax: :scss
-        }
-
+        import_url = URL.path_to_file_url(File.absolute_path(path, File.dirname(parent_path)))
+        canonical_url = "#{Protocol::IMPORT}#{import_url}"
+        @importer_results[canonical_url] = imports_to_native(imports)
         canonical_url
       end
 
       def load(canonical_url)
-        @importer_results[canonical_url]
+        if canonical_url.start_with?(Protocol::IMPORT)
+          @importer_results.delete(canonical_url)
+        elsif canonical_url.start_with?(Protocol::FILE)
+          @parent_urls.push(canonical_url)
+          if @importer_results.key?(canonical_url)
+            @importer_results.delete(canonical_url)
+          else
+            path = URL.file_url_to_path(canonical_url)
+            {
+              contents: File.read(path),
+              syntax: syntax(path),
+              source_map_url: canonical_url
+            }
+          end
+        elsif canonical_url.start_with?(Protocol::LOADED)
+          @parent_urls.pop
+          {
+            contents: '',
+            syntax: :scss
+          }
+        end
+      end
+
+      private
+
+      def load_paths
+        @load_paths ||= (@importer.options[:load_paths] || []) + SassC.load_paths
+      end
+
+      def resolve_path(path, parent_path, from_import)
+        [File.dirname(parent_path)].concat(load_paths).each do |load_path|
+          resolved = FileImporter.resolve_path(File.absolute_path(path, load_path), from_import)
+          return resolved unless resolved.nil?
+        end
+        nil
+      end
+
+      def syntax(path)
+        case File.extname(path)
+        when '.sass'
+          :indented
+        when '.css'
+          :css
+        else
+          :scss
+        end
+      end
+
+      def imports_to_native(imports)
+        {
+          contents: imports.flat_map do |import|
+            file_url = URL.path_to_file_url(import.path)
+            if import.source
+              @importer_results[file_url] = if import.source.is_a?(Hash)
+                                              {
+                                                contents: import.source[:contents],
+                                                syntax: import.source[:syntax],
+                                                source_map_url: file_url
+                                              }
+                                            else
+                                              {
+                                                contents: import.source,
+                                                syntax: syntax(import.path),
+                                                source_map_url: file_url
+                                              }
+                                            end
+            end
+            [
+              "@import #{"#{Protocol::LOAD}#{file_url}".inspect};",
+              "@import #{"#{Protocol::LOADED}#{file_url}".inspect};"
+            ]
+          end.join("\n"),
+          syntax: :scss
+        }
       end
     end
 
     private_constant :Importer
   end
 
+  class Sass2Scss
+    def self.convert(sass)
+      {
+        contents: sass,
+        syntax: :indented
+      }
+    end
+  end
+
   module Script
     module ValueConversion
       def self.from_native(value, options)
@@ -402,6 +533,10 @@ module SassC
 
     module_function
 
+    def parse(str)
+      PARSER.parse(str)
+    end
+
     def escape(str)
       PARSER.escape(str)
     end
@@ -413,7 +548,7 @@ module SassC
     def file_url_to_path(url)
       return if url.nil?
 
-      path = unescape(URI.parse(url).path)
+      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
     end
@@ -421,7 +556,6 @@ module SassC
     def path_to_file_url(path)
       return if path.nil?
 
-      path = File.absolute_path(path)
       path = "/#{path}" unless path.start_with?('/')
       URI::File.build([nil, escape(path)]).to_s
     end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sassc-embedded
 version: !ruby/object:Gem::Version
-  version: 1.2.0
+  version: 1.4.0
 platform: ruby
 authors:
 - なつき
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2022-03-27 00:00:00.000000000 Z
+date: 2022-04-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: sassc
@@ -138,8 +138,8 @@ homepage: https://github.com/ntkme/sassc-embedded-polyfill-ruby
 licenses:
 - MIT
 metadata:
-  documentation_uri: https://rubydoc.info/gems/sassc-embedded/1.2.0
-  source_code_uri: https://github.com/ntkme/sassc-embedded-polyfill-ruby/tree/v1.2.0
+  documentation_uri: https://rubydoc.info/gems/sassc-embedded/1.4.0
+  source_code_uri: https://github.com/ntkme/sassc-embedded-polyfill-ruby/tree/v1.4.0
   funding_uri: https://github.com/sponsors/ntkme
 post_install_message: 
 rdoc_options: []