dartsass-ruby 3.0.0

data/lib/sassc/importer.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module SassC
+  class Importer
+    attr_reader :options
+
+    def initialize(options)
+      @options = options
+    end
+
+    def imports(path, parent_path)
+      # A custom importer must override this method.
+      # Custom importer may return an Import, or an array of Imports.
+      raise NotImplementedError
+    end
+
+    class Import
+      attr_accessor :path, :source, :source_map_path
+
+      def initialize(path, source: nil, source_map_path: nil)
+        @path = path
+        @source = source
+        @source_map_path = source_map_path
+      end
+
+      def to_s
+        "Import: #{path} #{source} #{source_map_path}"
+      end
+    end
+  end
+end

data/lib/sassc/protocol.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module SassC
+  module Protocol
+    FILE = 'file:'
+    IMPORT = 'sassc-embedded-import:'
+    LOADED = 'sassc-embedded-loaded:'
+  end
+
+  private_constant :Protocol
+end

data/lib/sassc/sass_2_scss.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module SassC
+  class Sass2Scss
+    def self.convert(sass)
+      {
+        contents: sass,
+        syntax: :indented
+      }
+    end
+  end
+end

data/lib/sassc/script/functions.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module SassC
+  module Script
+    module Functions
+    end
+  end
+end

data/lib/sassc/script/value/bool.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+# A SassScript object representing a boolean (true or false) value.
+
+class SassC::Script::Value::Bool < SassC::Script::Value
+
+  # The true value in SassScript.
+  # This is assigned before new is overridden below so that we use the default implementation.
+  TRUE = new(true)
+
+  # The false value in SassScript.
+  # This is assigned before new is overridden below so that we use the default implementation.
+  FALSE = new(false)
+
+  # We override object creation so that users of the core API
+  # will not need to know that booleans are specific constants.
+  # Tests `value` for truthiness and returns the TRUE or FALSE constant.
+  def self.new(value)
+    value ? TRUE : FALSE
+  end
+
+  # The pure Ruby value of this Boolean
+  attr_reader :value
+  alias_method :to_bool, :value
+
+  # Returns the string "true" or "false" for this value
+  def to_s(opts = {})
+    @value.to_s
+  end
+  alias_method :to_sass, :to_s
+
+end

data/lib/sassc/script/value/color.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+# A SassScript object representing a CSS color.
+# This class provides a very bare-bones system for storing a RGB(A) or HSL(A)
+# color and converting it to a CSS color function.
+#
+# If your Sass method accepts a  color you will need to perform any
+# needed color mathematics or transformations yourself.
+
+class SassC::Script::Value::Color < SassC::Script::Value
+
+  attr_reader :red
+  attr_reader :green
+  attr_reader :blue
+  attr_reader :hue
+  attr_reader :saturation
+  attr_reader :lightness
+  attr_reader :alpha
+
+  # Creates a new color with (`red`, `green`, `blue`) or (`hue`, `saturation`, `lightness`
+  # values, plus an optional `alpha` transparency value.
+  def initialize(red:nil, green:nil, blue:nil, hue:nil, saturation:nil, lightness:nil, alpha:1.0)
+    if red && green && blue && alpha
+      @mode = :rgba
+      @red = red.to_i.clamp(0, 255)
+      @green = green.to_i.clamp(0, 255)
+      @blue = blue.to_i.clamp(0, 255)
+      @alpha = alpha.to_f.clamp(0.0, 1.0)
+    elsif hue && saturation && lightness && alpha
+      @mode = :hsla
+      @hue = hue.to_i.clamp(0, 360)
+      @saturation = saturation.to_i.clamp(0, 100)
+      @lightness = lightness.to_i.clamp(0, 100)
+      @alpha = alpha.to_f.clamp(0.0, 1.0)
+    else
+      raise SassC::UnsupportedValue, "Unable to determine color configuration for "
+    end
+  end
+
+  # Returns a CSS color declaration in the form
+  # `rgb(…)`, `rgba(…)`, `hsl(…)`, or `hsla(…)`.
+  def to_s
+    if rgba? && @alpha == 1.0
+      return "rgb(#{@red}, #{@green}, #{@blue})"
+    elsif rgba?
+      return "rgba(#{@red}, #{@green}, #{@blue}, #{alpha_string})"
+    elsif hsla? && @alpha == 1.0
+      return "hsl(#{@hue}, #{@saturation}%, #{@lightness}%)"
+    else # hsla?
+      return "hsla(#{@hue}, #{@saturation}%, #{@lightness}%, #{alpha_string})"
+    end
+  end
+
+  # True if this color has RGBA values
+  def rgba?
+    @mode == :rgba
+  end
+
+  # True if this color has HSLA values
+  def hlsa?
+    @mode == :hlsa
+  end
+
+  # Returns the alpha value of this color as a string
+  # and rounded to 8 decimal places.
+  def alpha_string
+    alpha.round(8).to_s
+  end
+
+  # Returns the values of this color in an array.
+  # Provided for compatibility between different SassC::Script::Value classes
+  def value
+    return [
+      red, green, blue,
+      hue, saturation, lightness,
+      alpha,
+    ].compact
+  end
+
+  # True if this Color is equal to `other_color`
+  def eql?(other_color)
+    unless other_color.is_a?(self.class)
+      raise ArgumentError, "No implicit conversion of #{other_color.class} to #{self.class}"
+    end
+    self.value == other_color.value
+  end
+  alias_method :==, :eql?
+
+  # Returns a numeric value for comparing two Color objects
+  # This method is used internally by the Hash class and is not the same as `.to_h`
+  def hash
+    value.hash
+  end
+
+end

data/lib/sassc/script/value/list.rb

@@ -0,0 +1,136 @@
+# frozen_string_literal: true
+
+# A SassScript object representing a CSS list.
+# This includes both comma-separated lists and space-separated lists.
+
+class SassC::Script::Value::List < SassC::Script::Value
+
+  # The Ruby array containing the contents of the list.
+  #
+  # @return [Array<Value>]
+  attr_reader :value
+  alias_method :to_a, :value
+
+  # The operator separating the values of the list.
+  # Either `:comma` or `:space`.
+  #
+  # @return [Symbol]
+  attr_reader :separator
+
+  # Whether the list is surrounded by square brackets.
+  #
+  # @return [Boolean]
+  attr_reader :bracketed
+
+  # Creates a new list.
+  #
+  # @param value [Array<Value>] See \{#value}
+  # @param separator [Symbol] See \{#separator}
+  # @param bracketed [Boolean] See \{#bracketed}
+  def initialize(value, separator: nil, bracketed: false)
+    super(value)
+    @separator = separator
+    @bracketed = bracketed
+  end
+
+  # @see Value#options=
+  def options=(options)
+    super
+    value.each {|v| v.options = options}
+  end
+
+  # @see Value#eq
+  def eq(other)
+    SassC::Script::Value::Bool.new(
+      other.is_a?(List) && value == other.value &&
+      separator == other.separator && bracketed == other.bracketed
+    )
+  end
+
+  def hash
+    @hash ||= [value, separator, bracketed].hash
+  end
+
+  # @see Value#to_s
+  def to_s(opts = {})
+    if !bracketed && value.empty?
+      raise SassC::SyntaxError.new("#{inspect} isn't a valid CSS value.")
+    end
+
+    members = value.
+      reject {|e| e.is_a?(Null) || e.is_a?(List) && e.value.empty?}.
+      map {|e| e.to_s(opts)}
+
+    contents = members.join(sep_str)
+    bracketed ? "[#{contents}]" : contents
+  end
+
+  # @see Value#to_sass
+  def to_sass(opts = {})
+    return bracketed ? "[]" : "()" if value.empty?
+    members = value.map do |v|
+      if element_needs_parens?(v)
+        "(#{v.to_sass(opts)})"
+      else
+        v.to_sass(opts)
+      end
+    end
+
+    if separator == :comma && members.length == 1
+      return "#{bracketed ? '[' : '('}#{members.first},#{bracketed ? ']' : ')'}"
+    end
+
+    contents = members.join(sep_str(nil))
+    bracketed ? "[#{contents}]" : contents
+  end
+
+  # @see Value#to_h
+  def to_h
+    return {} if value.empty?
+    super
+  end
+
+  # @see Value#inspect
+  def inspect
+    (bracketed ? '[' : '(') + value.map {|e| e.inspect}.join(sep_str(nil)) + (bracketed ? ']' : ')')
+  end
+
+  # Asserts an index is within the list.
+  #
+  # @private
+  #
+  # @param list [Sass::Script::Value::List] The list for which the index should be checked.
+  # @param n [Sass::Script::Value::Number] The index being checked.
+  def self.assert_valid_index(list, n)
+    if !n.int? || n.to_i == 0
+      raise ArgumentError.new("List index #{n} must be a non-zero integer")
+    elsif list.to_a.size == 0
+      raise ArgumentError.new("List index is #{n} but list has no items")
+    elsif n.to_i.abs > (size = list.to_a.size)
+      raise ArgumentError.new(
+        "List index is #{n} but list is only #{size} item#{'s' if size != 1} long")
+    end
+  end
+
+  private
+
+  def element_needs_parens?(element)
+    if element.is_a?(List)
+      return false if element.value.length < 2
+      return false if element.bracketed
+      precedence = Sass::Script::Parser.precedence_of(separator || :space)
+      return Sass::Script::Parser.precedence_of(element.separator || :space) <= precedence
+    end
+
+    return false unless separator == :space
+    return false unless element.is_a?(Sass::Script::Tree::UnaryOperation)
+    element.operator == :minus || element.operator == :plus
+  end
+
+  def sep_str(opts = options)
+    return ' ' if separator == :space
+    return ',' if opts && opts[:style] == :compressed
+    ', '
+  end
+
+end

data/lib/sassc/script/value/map.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+class SassC::Script::Value::Map < SassC::Script::Value
+
+  # The Ruby hash containing the contents of this map.
+  # @return [Hash<Node, Node>]
+  attr_reader :value
+  alias_method :to_h, :value
+
+  # Creates a new map.
+  #
+  # @param hash [Hash<Node, Node>]
+  def initialize(hash)
+    super(hash)
+  end
+
+  # @see Value#options=
+  def options=(options)
+    super
+    value.each do |k, v|
+      k.options = options
+      v.options = options
+    end
+  end
+
+  # @see Value#separator
+  def separator
+    :comma unless value.empty?
+  end
+
+  # @see Value#to_a
+  def to_a
+    value.map do |k, v|
+      list = SassC::Script::Value::List.new([k, v], separator: :space)
+      list.options = options
+      list
+    end
+  end
+
+  # @see Value#eq
+  def eq(other)
+    SassC::Script::Value::Bool.new(other.is_a?(Map) && value == other.value)
+  end
+
+  def hash
+    @hash ||= value.hash
+  end
+
+  # @see Value#to_s
+  def to_s(opts = {})
+    raise SassC::SyntaxError.new("#{inspect} isn't a valid CSS value.")
+  end
+
+  def to_sass(opts = {})
+    return "()" if value.empty?
+
+    to_sass = lambda do |value|
+      if value.is_a?(List) && value.separator == :comma
+        "(#{value.to_sass(opts)})"
+      else
+        value.to_sass(opts)
+      end
+    end
+
+    "(#{value.map {|(k, v)| "#{to_sass[k]}: #{to_sass[v]}"}.join(', ')})"
+  end
+  alias_method :inspect, :to_sass
+
+end