sass-embedded 1.58.0-x86_64-linux-musl

data/lib/sass/embedded.rb

@@ -0,0 +1,251 @@
+# frozen_string_literal: true
+
+require_relative '../../ext/sass/embedded'
+require_relative '../../ext/sass/embedded_sass_pb'
+require_relative 'compile_error'
+require_relative 'compile_result'
+require_relative 'embedded/async'
+require_relative 'embedded/channel'
+require_relative 'embedded/compiler'
+require_relative 'embedded/dispatcher'
+require_relative 'embedded/host'
+require_relative 'embedded/protofier'
+require_relative 'embedded/structifier'
+require_relative 'embedded/varint'
+require_relative 'embedded/version'
+require_relative 'logger/silent'
+require_relative 'logger/source_location'
+require_relative 'logger/source_span'
+require_relative 'value'
+
+# The Sass module.
+#
+# This communicates with Embedded Dart Sass using the Embedded Sass protocol.
+#
+# @example
+#   Sass.compile('style.scss')
+#
+# @example
+#   Sass.compile_string('h1 { font-size: 40px; }')
+module Sass
+  @instance = nil
+  @mutex = Mutex.new
+
+  # rubocop:disable Layout/LineLength
+  class << self
+    # Compiles the Sass file at +path+ to CSS.
+    # @overload compile(path, load_paths: [], charset: true, source_map: false, source_map_include_sources: false, style: :expanded, functions: {}, importers: [], alert_ascii: false, alert_color: nil, logger: nil, quiet_deps: false, verbose: false)
+    # @param (see Embedded#compile)
+    # @return (see Embedded#compile)
+    # @raise (see Embedded#compile)
+    # @see Embedded#compile
+    def compile(path, **kwargs)
+      instance.compile(path, **kwargs)
+    end
+
+    # Compiles a stylesheet whose contents is +source+ to CSS.
+    # @overload compile_string(source, importer: nil, load_paths: [], syntax: :scss, url: nil, charset: true, source_map: false, source_map_include_sources: false, style: :expanded, functions: {}, importers: [], alert_ascii: false, alert_color: nil, logger: nil, quiet_deps: false, verbose: false)
+    # @param (see Embedded#compile_string)
+    # @return (see Embedded#compile_string)
+    # @raise (see Embedded#compile_string)
+    # @see Embedded#compile_string
+    def compile_string(source, **kwargs)
+      instance.compile_string(source, **kwargs)
+    end
+
+    # @param (see Embedded#info)
+    # @return (see Embedded#info)
+    # @raise (see Embedded#info)
+    # @see Embedded#info
+    def info
+      instance.info
+    end
+
+    private
+
+    def instance
+      return @instance if @instance
+
+      @mutex.synchronize do
+        return @instance if @instance
+
+        @instance = Embedded.new
+        at_exit do
+          @instance.close
+        end
+      end
+
+      @instance
+    end
+  end
+  # rubocop:enable Layout/LineLength
+
+  # The {Embedded} host for using dart-sass-embedded. Each instance creates
+  # its own communication {Channel} with a dedicated compiler process.
+  #
+  # @example
+  #   embedded = Sass::Embedded.new
+  #   result = embedded.compile_string('h1 { font-size: 40px; }')
+  #   result = embedded.compile('style.scss')
+  #   embedded.close
+  class Embedded
+    def initialize
+      @channel = Channel.new
+    end
+
+    # Compiles the Sass file at +path+ to CSS.
+    # @param path [String]
+    # @param load_paths [Array<String>] Paths in which to look for stylesheets loaded by rules like
+    #   {@use}[https://sass-lang.com/documentation/at-rules/use] and {@import}[https://sass-lang.com/documentation/at-rules/import].
+    # @param charset [Boolean] By default, if the CSS document contains non-ASCII characters, Sass adds a +@charset+
+    #   declaration (in expanded output mode) or a byte-order mark (in compressed mode) to indicate its encoding to
+    #   browsers or other consumers. If +charset+ is +false+, these annotations are omitted.
+    # @param source_map [Boolean] Whether or not Sass should generate a source map.
+    # @param source_map_include_sources [Boolean] Whether Sass should include the sources in the generated source map.
+    # @param style [String, Symbol] The OutputStyle of the compiled CSS.
+    # @param functions [Hash<String, Proc>] Additional built-in Sass functions that are available in all stylesheets.
+    # @param importers [Array<Object>] Custom importers that control how Sass resolves loads from rules like
+    #   {@use}[https://sass-lang.com/documentation/at-rules/use] and {@import}[https://sass-lang.com/documentation/at-rules/import].
+    # @param alert_ascii [Boolean] If this is +true+, the compiler will exclusively use ASCII characters in its error
+    #   and warning messages. Otherwise, it may use non-ASCII Unicode characters as well.
+    # @param alert_color [Boolean] If this is +true+, the compiler will use ANSI color escape codes in its error and
+    #   warning messages. If it's +false+, it won't use these. If it's +nil+, the compiler will determine whether or
+    #   not to use colors depending on whether the user is using an interactive terminal.
+    # @param logger [Object] An object to use to handle warnings and/or debug messages from Sass.
+    # @param quiet_deps [Boolean] If this option is set to +true+, Sass won’t print warnings that are caused by
+    #   dependencies. A “dependency” is defined as any file that’s loaded through +load_paths+ or +importer+.
+    #   Stylesheets that are imported relative to the entrypoint are not considered dependencies.
+    # @param verbose [Boolean] By default, Dart Sass will print only five instances of the same deprecation warning per
+    #   compilation to avoid deluging users in console noise. If you set verbose to +true+, it will instead print every
+    #   deprecation warning it encounters.
+    # @return [CompileResult]
+    # @raise [CompileError]
+    # @see https://sass-lang.com/documentation/js-api/modules#compile
+    def compile(path,
+                load_paths: [],
+
+                charset: true,
+                source_map: false,
+                source_map_include_sources: false,
+                style: :expanded,
+
+                functions: {},
+                importers: [],
+
+                alert_ascii: false,
+                alert_color: nil,
+                logger: nil,
+                quiet_deps: false,
+                verbose: false)
+      raise ArgumentError, 'path must be set' if path.nil?
+
+      Host.new(@channel).compile_request(
+        path: path,
+        source: nil,
+        importer: nil,
+        load_paths: load_paths,
+        syntax: nil,
+        url: nil,
+        charset: charset,
+        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
+      )
+    end
+
+    # Compiles a stylesheet whose contents is +source+ to CSS.
+    # @param source [String]
+    # @param importer [Object] The importer to use to handle loads that are relative to the entrypoint stylesheet.
+    # @param load_paths [Array<String>] Paths in which to look for stylesheets loaded by rules like
+    #   {@use}[https://sass-lang.com/documentation/at-rules/use] and {@import}[https://sass-lang.com/documentation/at-rules/import].
+    # @param syntax [String, Symbol] The Syntax to use to parse the entrypoint stylesheet.
+    # @param url [String] The canonical URL of the entrypoint stylesheet. If this is passed along with +importer+, it's
+    #   used to resolve relative loads in the entrypoint stylesheet.
+    # @param charset [Boolean] By default, if the CSS document contains non-ASCII characters, Sass adds a +@charset+
+    #   declaration (in expanded output mode) or a byte-order mark (in compressed mode) to indicate its encoding to
+    #   browsers or other consumers. If +charset+ is +false+, these annotations are omitted.
+    # @param source_map [Boolean] Whether or not Sass should generate a source map.
+    # @param source_map_include_sources [Boolean] Whether Sass should include the sources in the generated source map.
+    # @param style [String, Symbol] The OutputStyle of the compiled CSS.
+    # @param functions [Hash<String, Proc>] Additional built-in Sass functions that are available in all stylesheets.
+    # @param importers [Array<Object>] Custom importers that control how Sass resolves loads from rules like
+    #   {@use}[https://sass-lang.com/documentation/at-rules/use] and {@import}[https://sass-lang.com/documentation/at-rules/import].
+    # @param alert_ascii [Boolean] If this is +true+, the compiler will exclusively use ASCII characters in its error
+    #   and warning messages. Otherwise, it may use non-ASCII Unicode characters as well.
+    # @param alert_color [Boolean] If this is +true+, the compiler will use ANSI color escape codes in its error and
+    #   warning messages. If it's +false+, it won't use these. If it's +nil+, the compiler will determine whether or
+    #   not to use colors depending on whether the user is using an interactive terminal.
+    # @param logger [Object] An object to use to handle warnings and/or debug messages from Sass.
+    # @param quiet_deps [Boolean] If this option is set to +true+, Sass won’t print warnings that are caused by
+    #   dependencies. A “dependency” is defined as any file that’s loaded through +load_paths+ or +importer+.
+    #   Stylesheets that are imported relative to the entrypoint are not considered dependencies.
+    # @param verbose [Boolean] By default, Dart Sass will print only five instances of the same deprecation warning per
+    #   compilation to avoid deluging users in console noise. If you set verbose to +true+, it will instead print every
+    #   deprecation warning it encounters.
+    # @return [CompileResult]
+    # @raise [CompileError]
+    # @see https://sass-lang.com/documentation/js-api/modules#compileString
+    def compile_string(source,
+                       importer: nil,
+                       load_paths: [],
+                       syntax: :scss,
+                       url: nil,
+
+                       charset: true,
+                       source_map: false,
+                       source_map_include_sources: false,
+                       style: :expanded,
+
+                       functions: {},
+                       importers: [],
+
+                       alert_ascii: false,
+                       alert_color: nil,
+                       logger: nil,
+                       quiet_deps: false,
+                       verbose: false)
+      raise ArgumentError, 'source must be set' if source.nil?
+
+      Host.new(@channel).compile_request(
+        path: nil,
+        source: source,
+        importer: importer,
+        load_paths: load_paths,
+        syntax: syntax,
+        url: url,
+        charset: charset,
+        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
+      )
+    end
+
+    # @return [String] Information about the Sass implementation.
+    # @see https://sass-lang.com/documentation/js-api/modules#info
+    def info
+      @info ||= Host.new(@channel).version_request
+    end
+
+    def close
+      @channel.close
+    end
+
+    def closed?
+      @channel.closed?
+    end
+  end
+end

data/lib/sass/logger/silent.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Sass
+  # A namespace for built-in Loggers.
+  #
+  # @see https://sass-lang.com/documentation/js-api/modules/Logger
+  module Logger
+    module_function
+
+    # A Logger that silently ignores all warnings and debug messages.
+    def silent
+      Silent
+    end
+
+    # A Logger that silently ignores all warnings and debug messages.
+    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/logger/source_location.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Sass
+  module Logger
+    # A specific location within a source file.
+    #
+    # This is always associated with a {SourceSpan} which indicates which file it refers to.
+    #
+    # @see https://sass-lang.com/documentation/js-api/interfaces/SourceLocation
+    class SourceLocation
+      # @return [Integer]
+      attr_reader :offset, :line, :column
+
+      def initialize(offset, line, column)
+        @offset = offset
+        @line = line
+        @column = column
+      end
+    end
+  end
+end

data/lib/sass/logger/source_span.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Sass
+  module Logger
+    # A span of text within a source file.
+    #
+    # @see https://sass-lang.com/documentation/js-api/interfaces/SourceSpan
+    class SourceSpan
+      # @return [SourceLocation]
+      attr_reader :start, :end
+
+      # @return [String]
+      attr_reader :text
+
+      # @return [String, nil]
+      attr_reader :url, :context
+
+      def initialize(start, end_, text, url, context)
+        @start = start
+        @end = end_
+        @text = text
+        @url = url == '' ? nil : url
+        @context = context == '' ? nil : context
+      end
+    end
+  end
+end

data/lib/sass/script_error.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Sass
+  # An exception thrown by Sass Script.
+  class ScriptError < StandardError
+    def initialize(message, name = nil)
+      super(name.nil? ? message : "$#{name}: #{message}")
+    end
+  end
+end

data/lib/sass/value/argument_list.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Sass
+  module Value
+    # Sass's argument list type.
+    #
+    # An argument list comes from a rest argument. It's distinct from a normal {List} in that it may contain a keyword
+    # map as well as the positional arguments.
+    #
+    # @see https://sass-lang.com/documentation/js-api/classes/SassArgumentList
+    class ArgumentList < Value::List
+      # @param contents [Array<Value>]
+      # @param keywords [Hash<::String, Value>]
+      # @param separator [::String]
+      def initialize(contents = [], keywords = {}, separator = ',')
+        super(contents, separator: separator)
+
+        @id = 0
+        @keywords_accessed = false
+        @keywords = keywords.transform_keys(&:to_s).freeze
+      end
+
+      # @return [Hash<::String, Value>]
+      def keywords
+        @keywords_accessed = true
+        @keywords
+      end
+
+      private
+
+      def initialize_copy(orig)
+        super
+        @id = 0
+      end
+    end
+  end
+end

data/lib/sass/value/boolean.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Sass
+  module Value
+    # Sass's boolean type.
+    #
+    # @see https://sass-lang.com/documentation/js-api/classes/SassBoolean
+    class Boolean
+      include Value
+
+      # @param value [::Boolean]
+      def initialize(value)
+        @value = value
+      end
+
+      # @return [::Boolean]
+      attr_reader :value
+
+      # @return [Boolean]
+      def !
+        value ? Boolean::FALSE : Boolean::TRUE
+      end
+
+      # @return [::Boolean]
+      def ==(other)
+        other.is_a?(Sass::Value::Boolean) && other.value == value
+      end
+
+      # @return [Integer]
+      def hash
+        @hash ||= value.hash
+      end
+
+      alias to_bool value
+
+      # @return [Boolean]
+      def assert_boolean(_name = nil)
+        self
+      end
+
+      # Sass's true value.
+      TRUE = Boolean.new(true)
+
+      # Sass's false value.
+      FALSE = Boolean.new(false)
+
+      def self.new(value)
+        value ? Boolean::TRUE : Boolean::FALSE
+      end
+    end
+  end
+end

data/lib/sass/value/color.rb

@@ -0,0 +1,253 @@
+# frozen_string_literal: true
+
+module Sass
+  module Value
+    # Sass's color type.
+    #
+    # No matter what representation was originally used to create this color, all of its channels are accessible.
+    #
+    # @see https://sass-lang.com/documentation/js-api/classes/SassColor
+    class Color
+      include Value
+
+      # @param red [Numeric]
+      # @param green [Numeric]
+      # @param blue [Numeric]
+      # @param hue [Numeric]
+      # @param saturation [Numeric]
+      # @param lightness [Numeric]
+      # @param whiteness [Numeric]
+      # @param blackness [Numeric]
+      # @param alpha [Numeric]
+      def initialize(red: nil,
+                     green: nil,
+                     blue: nil,
+                     hue: nil,
+                     saturation: nil,
+                     lightness: nil,
+                     whiteness: nil,
+                     blackness: nil,
+                     alpha: nil)
+        @alpha = alpha.nil? ? 1 : FuzzyMath.assert_between(alpha, 0, 1, 'alpha')
+        if red && green && blue
+          @red = FuzzyMath.assert_between(FuzzyMath.round(red), 0, 255, 'red')
+          @green = FuzzyMath.assert_between(FuzzyMath.round(green), 0, 255, 'green')
+          @blue = FuzzyMath.assert_between(FuzzyMath.round(blue), 0, 255, 'blue')
+        elsif hue && saturation && lightness
+          @hue = hue % 360
+          @saturation = FuzzyMath.assert_between(saturation, 0, 100, 'saturation')
+          @lightness = FuzzyMath.assert_between(lightness, 0, 100, 'lightness')
+        elsif hue && whiteness && blackness
+          @hue = hue % 360
+          @whiteness = FuzzyMath.assert_between(whiteness, 0, 100, 'whiteness')
+          @blackness = FuzzyMath.assert_between(blackness, 0, 100, 'blackness')
+          hwb_to_rgb
+          @whiteness = @blackness = nil
+        else
+          raise Sass::ScriptError, 'Invalid Color'
+        end
+      end
+
+      # @return [Integer]
+      def red
+        hsl_to_rgb unless defined? @red
+
+        @red
+      end
+
+      # @return [Integer]
+      def green
+        hsl_to_rgb unless defined? @green
+
+        @green
+      end
+
+      # @return [Integer]
+      def blue
+        hsl_to_rgb unless defined? @blue
+
+        @blue
+      end
+
+      # @return [Numeric]
+      def hue
+        rgb_to_hsl unless defined? @hue
+
+        @hue
+      end
+
+      # @return [Numeric]
+      def saturation
+        rgb_to_hsl unless defined? @saturation
+
+        @saturation
+      end
+
+      # @return [Numeric]
+      def lightness
+        rgb_to_hsl unless defined? @lightness
+
+        @lightness
+      end
+
+      # @return [Numeric]
+      def whiteness
+        @whiteness ||= Rational([red, green, blue].min, 255) * 100
+      end
+
+      # @return [Numeric]
+      def blackness
+        @blackness ||= 100 - (Rational([red, green, blue].max, 255) * 100)
+      end
+
+      # @return [Numeric]
+      attr_reader :alpha
+
+      # @param red [Numeric]
+      # @param green [Numeric]
+      # @param blue [Numeric]
+      # @param hue [Numeric]
+      # @param saturation [Numeric]
+      # @param lightness [Numeric]
+      # @param whiteness [Numeric]
+      # @param blackness [Numeric]
+      # @param alpha [Numeric]
+      # @return [Color]
+      def change(red: nil,
+                 green: nil,
+                 blue: nil,
+                 hue: nil,
+                 saturation: nil,
+                 lightness: nil,
+                 whiteness: nil,
+                 blackness: nil,
+                 alpha: nil)
+        if whiteness || blackness
+          Sass::Value::Color.new(hue: hue || self.hue,
+                                 whiteness: whiteness || self.whiteness,
+                                 blackness: blackness || self.blackness,
+                                 alpha: alpha || self.alpha)
+        elsif hue || saturation || lightness
+          Sass::Value::Color.new(hue: hue || self.hue,
+                                 saturation: saturation || self.saturation,
+                                 lightness: lightness || self.lightness,
+                                 alpha: alpha || self.alpha)
+        elsif red || green || blue
+          Sass::Value::Color.new(red: red ? FuzzyMath.round(red) : self.red,
+                                 green: green ? FuzzyMath.round(green) : self.green,
+                                 blue: blue ? FuzzyMath.round(blue) : self.blue,
+                                 alpha: alpha || self.alpha)
+        else
+          dup.instance_eval do
+            @alpha = FuzzyMath.assert_between(alpha, 0, 1, 'alpha')
+            self
+          end
+        end
+      end
+
+      # @return [::Boolean]
+      def ==(other)
+        other.is_a?(Sass::Value::Color) &&
+          other.red == red &&
+          other.green == green &&
+          other.blue == blue &&
+          other.alpha == alpha
+      end
+
+      # @return [Integer]
+      def hash
+        @hash ||= [red, green, blue, alpha].hash
+      end
+
+      # @return [Color]
+      def assert_color(_name = nil)
+        self
+      end
+
+      private
+
+      def rgb_to_hsl
+        scaled_red = Rational(red, 255)
+        scaled_green = Rational(green, 255)
+        scaled_blue = Rational(blue, 255)
+
+        max = [scaled_red, scaled_green, scaled_blue].max
+        min = [scaled_red, scaled_green, scaled_blue].min
+        delta = max - min
+
+        if max == min
+          @hue = 0
+        elsif max == scaled_red
+          @hue = ((scaled_green - scaled_blue) * 60 / delta) % 360
+        elsif max == scaled_green
+          @hue = (((scaled_blue - scaled_red) * 60 / delta) + 120) % 360
+        elsif max == scaled_blue
+          @hue = (((scaled_red - scaled_green) * 60 / delta) + 240) % 360
+        end
+
+        lightness = @lightness = (max + min) * 50
+
+        @saturation = if max == min
+                        0
+                      elsif lightness < 50
+                        delta * 100 / (max + min)
+                      else
+                        delta * 100 / (2 - max - min)
+                      end
+      end
+
+      def hsl_to_rgb
+        scaled_hue = Rational(hue, 360)
+        scaled_saturation = Rational(saturation, 100)
+        scaled_lightness = Rational(lightness, 100)
+
+        tmp2 = if scaled_lightness <= 0.5
+                 scaled_lightness * (scaled_saturation + 1)
+               else
+                 scaled_lightness + scaled_saturation - (scaled_lightness * scaled_saturation)
+               end
+        tmp1 = (scaled_lightness * 2) - tmp2
+        @red = FuzzyMath.round(hsl_hue_to_rgb(tmp1, tmp2, scaled_hue + Rational(1, 3)) * 255)
+        @green = FuzzyMath.round(hsl_hue_to_rgb(tmp1, tmp2, scaled_hue) * 255)
+        @blue = FuzzyMath.round(hsl_hue_to_rgb(tmp1, tmp2, scaled_hue - Rational(1, 3)) * 255)
+      end
+
+      def hsl_hue_to_rgb(tmp1, tmp2, hue)
+        hue += 1 if hue.negative?
+        hue -= 1 if hue > 1
+
+        if hue < Rational(1, 6)
+          tmp1 + ((tmp2 - tmp1) * hue * 6)
+        elsif hue < Rational(1, 2)
+          tmp2
+        elsif hue < Rational(2, 3)
+          tmp1 + ((tmp2 - tmp1) * (Rational(2, 3) - hue) * 6)
+        else
+          tmp1
+        end
+      end
+
+      def hwb_to_rgb
+        scaled_hue = Rational(hue, 360)
+        scaled_whiteness = Rational(whiteness, 100)
+        scaled_blackness = Rational(blackness, 100)
+
+        sum = scaled_whiteness + scaled_blackness
+        if sum > 1
+          scaled_whiteness /= sum
+          scaled_blackness /= sum
+        end
+
+        factor = 1 - scaled_whiteness - scaled_blackness
+        @red = hwb_hue_to_rgb(factor, scaled_whiteness, scaled_hue + Rational(1, 3))
+        @green = hwb_hue_to_rgb(factor, scaled_whiteness, scaled_hue)
+        @blue = hwb_hue_to_rgb(factor, scaled_whiteness, scaled_hue - Rational(1, 3))
+      end
+
+      def hwb_hue_to_rgb(factor, scaled_whiteness, scaled_hue)
+        channel = (hsl_hue_to_rgb(0, 1, scaled_hue) * factor) + scaled_whiteness
+        FuzzyMath.round(channel * 255)
+      end
+    end
+  end
+end