sassc-embedded 1.1.0 → 1.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 70c90e46b79aadd3b3ba316365eb9d45a854e75be4634a008f4e7e54cec17dd0
-  data.tar.gz: 1991dc737c3739f2c9b497e904b5dda5dd734cdb55fdba6dd3e65fcacc81086e
+  metadata.gz: cdd5607c689b8388cf0c07abc26c3769ef50007ddd6b46432b277f7631bceb7f
+  data.tar.gz: 510835f24a3d66cf516bfd56acb0efd729d000cde730ef64908dfd5645f5aa12
 SHA512:
-  metadata.gz: '09c1017da2a0fd5b1bbb35e9b60514b2f687de9a745f5540317582336c34c7b8a43e201cf5f2efe8a1fdb2e18f0123537690902db504576923a5df96b898ff7f'
-  data.tar.gz: cb1e8fef114385a5e8cc622e88e1e42ea3763c3a378108067b341865de63f8add6103a7e0b7874ddd6b2981e78dc53ada984df1809056cc65621382ac8865957
+  metadata.gz: 93bbe6c1e4ff6e2fc4209e9390fd4775f029f0efb60606ab64cf9ee71a6afbc64d658c7572fd9c0719a134e8e192c5e8200d8ac2530e691cb84ae3fc14a31686
+  data.tar.gz: 1eed6fff6d57ac4ac56965de504ee876bd6dbbebb93880edefef2de604eb99536660487ae5c1ebcd6991270904f4700b42a54790dd7c233e303a66755120f01d

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.1.0'
+    VERSION = '1.3.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)
@@ -163,8 +168,8 @@ module SassC
     private
 
     def arguments_from_native_list(native_argument_list)
-      native_argument_list.map do |embedded_value|
-        Script::ValueConversion.from_native embedded_value, @options
+      native_argument_list.map do |native_value|
+        Script::ValueConversion.from_native(native_value, @options)
       end.compact
     end
 
@@ -175,7 +180,7 @@ module SassC
         raise ::Sass::ScriptError
       end
     rescue StandardError => e
-      unless e.full_message.include? e.cause.full_message
+      unless e.full_message.include?(e.cause.full_message)
         ::Sass::ScriptError.class_eval do
           def full_message(*args, **kwargs)
             full_message = super(*args, **kwargs)
@@ -192,86 +197,196 @@ module SassC
 
   class ImportHandler
     def setup(_native_options)
-      if @importer
-        [FileImporter.new, Importer.new(@importer)]
-      else
-        [FileImporter.new]
-      end
+      Importer.new(@importer) if @importer
     end
 
     class FileImporter
-      def find_file_url(url, **_kwargs)
-        return url if url.start_with?('file:')
+      class << self
+        def resolve_path(path, from_import)
+          ext = File.extname(path)
+          if ['.sass', '.scss', '.css'].include?(ext)
+            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 = {}
+        @base_url = URL.parse(URL.path_to_file_url("#{File.absolute_path('')}/"))
+        @parent_urls = [URL.parse(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 = @parent_urls.last.route_from(@base_url).to_s
 
-          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(URL.parse(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] = {
+                contents: import.source,
+                syntax: syntax(import.path),
+                source_map_url: file_url
+              }
+            end
+            [
+              "@import #{"#{Protocol::LOAD}#{file_url}".inspect};",
+              "@import #{"#{Protocol::LOADED}#{file_url}".inspect};"
+            ]
+          end.join("\n"),
+          syntax: :scss
+        }
       end
     end
 
@@ -402,6 +517,10 @@ module SassC
 
     module_function
 
+    def parse(str)
+      PARSER.parse(str)
+    end
+
     def escape(str)
       PARSER.escape(str)
     end
@@ -413,7 +532,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,9 +540,10 @@ module SassC
     def path_to_file_url(path)
       return if path.nil?
 
-      path = File.absolute_path(path)
-      path = "/#{path}" unless path.start_with? '/'
+      path = "/#{path}" unless path.start_with?('/')
       URI::File.build([nil, escape(path)]).to_s
     end
   end
+
+  private_constant :URL
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sassc-embedded
 version: !ruby/object:Gem::Version
-  version: 1.1.0
+  version: 1.3.0
 platform: ruby
 authors:
 - なつき
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2022-03-22 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.1.0
-  source_code_uri: https://github.com/ntkme/sassc-embedded-polyfill-ruby/tree/v1.1.0
+  documentation_uri: https://rubydoc.info/gems/sassc-embedded/1.3.0
+  source_code_uri: https://github.com/ntkme/sassc-embedded-polyfill-ruby/tree/v1.3.0
   funding_uri: https://github.com/sponsors/ntkme
 post_install_message: 
 rdoc_options: []