sass-embedded 0.9.3 → 0.13.0

data/lib/sass/embedded.rb

@@ -1,14 +1,15 @@
 # frozen_string_literal: true
 
-require 'base64'
-require 'json'
+require_relative 'compile_error'
+require_relative 'compile_result'
+require_relative 'importer_result'
 require_relative 'embedded/channel'
 require_relative 'embedded/compile_context'
-require_relative 'embedded/error'
-require_relative 'embedded/result'
-require_relative 'embedded/util'
+require_relative 'embedded/render'
+require_relative 'embedded/url'
 require_relative 'embedded/version'
 require_relative 'embedded/version_context'
+require_relative 'logger'
 
 module Sass
   # The {Embedded} host for using dart-sass-embedded. Each instance creates
@@ -16,109 +17,113 @@ module Sass
   #
   # @example
   #   embedded = Sass::Embedded.new
-  #   result = embedded.render(data: 'h1 { font-size: 40px; }')
-  #   result = embedded.render(file: 'style.css')
+  #   result = embedded.compile_string('h1 { font-size: 40px; }')
+  #   result = embedded.compile('style.scss')
   #   embedded.close
   class Embedded
-    def self.include_paths
-      @include_paths ||= if ENV['SASS_PATH']
-                           ENV['SASS_PATH'].split(File::PATH_SEPARATOR)
-                         else
-                           []
-                         end
-    end
-
     def initialize
       @channel = Channel.new
     end
 
-    # The {Embedded#info} method.
+    # The {Embedded#compile} method.
     #
+    # @return [CompileResult]
+    # @raise [CompileError]
     # @raise [ProtocolError]
-    def info
-      @info ||= VersionContext.new(@channel).receive_message
-    end
+    def compile(path,
+                load_paths: [],
 
-    # The {Embedded#render} method.
-    #
-    # See {file:README.md#options} for supported options.
-    #
-    # @return [RenderResult]
-    # @raise [ProtocolError]
-    # @raise [RenderError]
-    def render(data: nil,
-               file: nil,
-               indented_syntax: false,
-               include_paths: [],
-               output_style: :expanded,
-               indent_type: :space,
-               indent_width: 2,
-               linefeed: :lf,
-               source_map: false,
-               out_file: nil,
-               omit_source_map_url: false,
-               source_map_contents: false,
-               source_map_embed: false,
-               source_map_root: '',
-               functions: {},
-               importer: [])
-      start = Util.now
+                source_map: false,
+                source_map_include_sources: false,
+                style: :expanded,
 
-      indent_type = parse_indent_type(indent_type)
-      indent_width = parse_indent_width(indent_width)
-      linefeed = parse_linefeed(linefeed)
+                functions: {},
+                importers: [],
+
+                alert_ascii: false,
+                alert_color: $stderr.tty?,
+                logger: nil,
+                quiet_deps: false,
+                verbose: false)
+
+      raise ArgumentError, 'path must be set' if path.nil?
 
       message = CompileContext.new(@channel,
-                                   data: data,
-                                   file: file,
-                                   indented_syntax: indented_syntax,
-                                   include_paths: include_paths,
-                                   output_style: output_style,
+                                   path: path,
+                                   source: nil,
+                                   importer: nil,
+                                   load_paths: load_paths,
+                                   syntax: nil,
+                                   url: nil,
                                    source_map: source_map,
-                                   out_file: out_file,
+                                   source_map_include_sources: source_map_include_sources,
+                                   style: style,
                                    functions: functions,
-                                   importer: importer).receive_message
+                                   importers: importers,
+                                   alert_color: alert_color,
+                                   alert_ascii: alert_ascii,
+                                   logger: logger,
+                                   quiet_deps: quiet_deps,
+                                   verbose: verbose).receive_message
+
+      raise CompileError.from_proto(message.failure) if message.failure
 
-      if message.failure
-        raise RenderError.new(
-          message.failure.message,
-          message.failure.formatted,
-          if message.failure.span.nil?
-            nil
-          elsif message.failure.span.url == ''
-            'stdin'
-          else
-            Util.path_from_file_uri(message.failure.span.url)
-          end,
-          message.failure.span ? message.failure.span.start.line + 1 : nil,
-          message.failure.span ? message.failure.span.start.column + 1 : nil,
-          1
-        )
-      end
+      CompileResult.from_proto(message.success)
+    end
 
-      map, source_map = post_process_map(map: message.success.source_map,
-                                         data: data,
-                                         file: file,
-                                         out_file: out_file,
-                                         source_map: source_map,
-                                         source_map_contents: source_map_contents,
-                                         source_map_root: source_map_root)
+    # The {Embedded#compile_string} method.
+    #
+    # @return [CompileResult]
+    # @raise [CompileError]
+    # @raise [ProtocolError]
+    def compile_string(source,
+                       importer: nil,
+                       load_paths: [],
+                       syntax: :scss,
+                       url: nil,
+
+                       source_map: false,
+                       source_map_include_sources: false,
+                       style: :expanded,
+
+                       functions: {},
+                       importers: [],
+
+                       alert_ascii: false,
+                       alert_color: $stderr.tty?,
+                       logger: nil,
+                       quiet_deps: false,
+                       verbose: false)
+      raise ArgumentError, 'source must be set' if source.nil?
 
-      css = post_process_css(css: message.success.css,
-                             indent_type: indent_type,
-                             indent_width: indent_width,
-                             linefeed: linefeed,
-                             map: map,
-                             out_file: out_file,
-                             omit_source_map_url: omit_source_map_url,
-                             source_map: source_map,
-                             source_map_embed: source_map_embed)
+      message = CompileContext.new(@channel,
+                                   path: nil,
+                                   source: source,
+                                   importer: importer,
+                                   load_paths: load_paths,
+                                   syntax: syntax,
+                                   url: url,
+                                   source_map: source_map,
+                                   source_map_include_sources: source_map_include_sources,
+                                   style: style,
+                                   functions: functions,
+                                   importers: importers,
+                                   alert_color: alert_color,
+                                   alert_ascii: alert_ascii,
+                                   logger: logger,
+                                   quiet_deps: quiet_deps,
+                                   verbose: verbose).receive_message
 
-      finish = Util.now
+      raise CompileError.from_proto(message.failure) if message.failure
 
-      stats = RenderResultStats.new(file.nil? ? 'data' : file, start, finish, finish - start)
+      CompileResult.from_proto(message.success)
+    end
 
-      RenderResult.new(css, map, stats)
+    # The {Embedded#info} method.
+    #
+    # @raise [ProtocolError]
+    def info
+      @info ||= VersionContext.new(@channel).receive_message
     end
 
     def close
@@ -128,129 +133,5 @@ module Sass
     def closed?
       @channel.closed?
     end
-
-    private
-
-    def post_process_map(map:,
-                         data:,
-                         file:,
-                         out_file:,
-                         source_map:,
-                         source_map_contents:,
-                         source_map_root:)
-      return if map.nil? || map.empty?
-
-      map_data = JSON.parse(map)
-
-      map_data['sourceRoot'] = source_map_root
-
-      source_map_path = if source_map.is_a? String
-                          source_map
-                        else
-                          "#{out_file}.map"
-                        end
-
-      source_map_dir = File.dirname(source_map_path)
-
-      if out_file
-        map_data['file'] = Util.relative_path(source_map_dir, out_file)
-      elsif file
-        ext = File.extname(file)
-        map_data['file'] = "#{file[0..(ext.empty? ? -1 : -ext.length - 1)]}.css"
-      else
-        map_data['file'] = 'stdin.css'
-      end
-
-      map_data['sourcesContent'] = [] if source_map_contents
-
-      file = File.absolute_path(file) unless file.nil?
-
-      map_data['sources'].map! do |source|
-        if source.start_with? 'file://'
-          path = Util.path_from_file_uri(source)
-          content = if path == file && !data.nil?
-                      data
-                    else
-                      begin
-                        File.read(path)
-                      rescue StandardError
-                        nil
-                      end
-                    end
-          map_data['sourcesContent'].push(content) if source_map_contents
-          Util.relative_path(source_map_dir, path)
-        else
-          map_data['sourcesContent'].push(nil) if source_map_contents
-          source
-        end
-      end
-
-      [-JSON.generate(map_data), source_map_path]
-    end
-
-    def post_process_css(css:,
-                         indent_type:,
-                         indent_width:,
-                         linefeed:,
-                         map:,
-                         omit_source_map_url:,
-                         out_file:,
-                         source_map:,
-                         source_map_embed:)
-      css = +css
-      if indent_width != 2 || indent_type.to_sym != :space
-        indent = indent_type * indent_width
-        css.gsub!(/^ +/) do |space|
-          indent * (space.length / 2)
-        end
-      end
-      css.gsub!("\n", linefeed) if linefeed != "\n"
-
-      unless map.nil? || omit_source_map_url == true
-        url = if source_map_embed
-                "data:application/json;base64,#{Base64.strict_encode64(map)}"
-              elsif out_file
-                Util.relative_path(File.dirname(out_file), source_map)
-              else
-                source_map
-              end
-        css += "#{linefeed}#{linefeed}/*# sourceMappingURL=#{url} */"
-      end
-
-      -css
-    end
-
-    def parse_indent_type(indent_type)
-      case indent_type.to_sym
-      when :space
-        ' '
-      when :tab
-        "\t"
-      else
-        raise ArgumentError, 'indent_type must be one of :space, :tab'
-      end
-    end
-
-    def parse_indent_width(indent_width)
-      raise ArgumentError, 'indent_width must be an integer' unless indent_width.is_a? Integer
-      raise RangeError, 'indent_width must be in between 0 and 10 (inclusive)' unless indent_width.between? 0, 10
-
-      indent_width
-    end
-
-    def parse_linefeed(linefeed)
-      case linefeed.to_sym
-      when :lf
-        "\n"
-      when :lfcr
-        "\n\r"
-      when :cr
-        "\r"
-      when :crlf
-        "\r\n"
-      else
-        raise ArgumentError, 'linefeed must be one of :lf, :lfcr, :cr, :crlf'
-      end
-    end
   end
 end

data/lib/sass/file_importer.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Sass
+  # The {FileImporter} interface.
+  class FileImporter
+    def find_file_url(url, from_import:) # rubocop:disable Lint/UnusedMethodArgument
+      raise NotImplementedError, 'FileImporter#find_file_url must be implemented'
+    end
+  end
+end

data/lib/sass/importer.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Sass
+  # The {Importer} interface.
+  class Importer
+    def canonicalize(url) # rubocop:disable Lint/UnusedMethodArgument
+      raise NotImplementedError, 'Importer#canonicalize must be implemented'
+    end
+
+    def load(canonical_url) # rubocop:disable Lint/UnusedMethodArgument
+      raise NotImplementedError, 'Importer#load must be implemented'
+    end
+  end
+end

data/lib/sass/importer_result.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Sass
+  # The {ImporterResult} of {Importer#load}.
+  class ImporterResult
+    attr_reader :contents, :syntax, :source_map_url
+
+    def initialize(contents, syntax, source_map_url = nil)
+      @contents = contents
+      @syntax = syntax
+      @source_map_url = source_map_url
+    end
+  end
+end

data/lib/sass/logger/source_location.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Sass
+  module Logger
+    # The {SourceLocation} in {SourceSpan}.
+    class SourceLocation
+      attr_reader :offset, :line, :column
+
+      def initialize(offset, line, column)
+        @offset = offset
+        @line = line
+        @column = column
+      end
+
+      def self.from_proto(source_location)
+        return nil if source_location.nil?
+
+        SourceLocation.new(source_location.offset,
+                           source_location.line,
+                           source_location.column)
+      end
+    end
+  end
+end

data/lib/sass/logger/source_span.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require_relative 'source_location'
+
+module Sass
+  module Logger
+    # The {SourceSpan} in {CompileError}.
+    class SourceSpan
+      attr_reader :start, :end, :text, :url, :context
+
+      def initialize(start, end_, text, url, context)
+        @start = start
+        @end = end_
+        @text = text
+        @url = url == '' ? nil : url
+        @context = context == '' ? nil : context
+      end
+
+      def self.from_proto(source_span)
+        return nil if source_span.nil?
+
+        SourceSpan.new(SourceLocation.from_proto(source_span.start),
+                       SourceLocation.from_proto(source_span.end),
+                       source_span.text,
+                       source_span.url,
+                       source_span.context)
+      end
+    end
+  end
+end

data/lib/sass/logger.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Sass
+  # The {Logger} module.
+  module Logger
+    module_function
+
+    # The instance of a silent {Logger}.
+    def silent
+      Silent
+    end
+
+    # The silent {Logger}.
+    module Silent
+      module_function
+
+      def warn(message, deprecation: false, span: nil, stack: nil); end
+
+      def debug(message, span: nil); end
+    end
+
+    private_constant :Silent
+  end
+end

data/lib/sass.rb

@@ -6,6 +6,35 @@ require_relative 'sass/embedded'
 # the Embedded Sass protocol.
 module Sass
   class << self
+    # The global {.compile} method. This instantiates a global {Embedded} instance
+    # and calls {Embedded#compile}.
+    #
+    # See {Embedded#compile} for supported options.
+    #
+    # @example
+    #   Sass.compile('style.scss')
+    # @return [CompileResult]
+    # @raise [CompileError]
+    # @raise [ProtocolError]
+    def compile(path, **kwargs)
+      instance.compile(path, **kwargs)
+    end
+
+    # The global {.compile_string} method. This instantiates a global {Embedded} instance
+    # and calls {Embedded#compile_string}.
+    #
+    # See {Embedded#compile_string} for supported options.
+    #
+    # @example
+    #   Sass.compile_string('h1 { font-size: 40px; }')
+    # @return [CompileResult]
+    # @raise [CompileError]
+    # @raise [ProtocolError]
+    def compile_string(source, **kwargs)
+      instance.compile_string(source, **kwargs)
+    end
+
+    # @deprecated
     # The global {.include_paths} for Sass files. This is meant for plugins and
     # libraries to register the paths to their Sass stylesheets to that they may
     # be included via `@import` or `@use`. This include path is used by every
@@ -32,10 +61,11 @@ module Sass
       instance.info
     end
 
+    # @deprecated
     # The global {.render} method. This instantiates a global {Embedded} instance
     # and calls {Embedded#render}.
     #
-    # See {file:README.md#options} for supported options.
+    # See {Embedded#render} for supported options.
     #
     # @example
     #   Sass.render(data: 'h1 { font-size: 40px; }')