sassc 1.12.1 → 2.0.0

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 = SassC::Util.clamp(red.to_i, 0, 255)
+      @green = SassC::Util.clamp(green.to_i, 0, 255)
+      @blue = SassC::Util.clamp(blue.to_i, 0, 255)
+      @alpha = SassC::Util.clamp(alpha.to_f, 0.0, 1.0)
+    elsif hue && saturation && lightness && alpha
+      @mode = :hsla
+      @hue = SassC::Util.clamp(hue.to_i, 0, 360)
+      @saturation = SassC::Util.clamp(saturation.to_i, 0, 100)
+      @lightness = SassC::Util.clamp(lightness.to_i, 0, 100)
+      @alpha = SassC::Util.clamp(alpha.to_f, 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

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

@@ -0,0 +1,389 @@
+# frozen_string_literal: true
+
+# A SassScript object representing a number.
+# SassScript numbers can have decimal values,
+# and can also have units.
+# For example, `12`, `1px`, and `10.45em`
+# are all valid values.
+#
+# Numbers can also have more complex units, such as `1px*em/in`.
+# These cannot be inputted directly in Sass code at the moment.
+
+class SassC::Script::Value::Number < SassC::Script::Value
+
+  # The Ruby value of the number.
+  #
+  # @return [Numeric]
+  attr_reader :value
+
+  # A list of units in the numerator of the number.
+  # For example, `1px*em/in*cm` would return `["px", "em"]`
+  # @return [Array<String>]
+  attr_reader :numerator_units
+
+  # A list of units in the denominator of the number.
+  # For example, `1px*em/in*cm` would return `["in", "cm"]`
+  # @return [Array<String>]
+  attr_reader :denominator_units
+
+  # The original representation of this number.
+  # For example, although the result of `1px/2px` is `0.5`,
+  # the value of `#original` is `"1px/2px"`.
+  #
+  # This is only non-nil when the original value should be used as the CSS value,
+  # as in `font: 1px/2px`.
+  #
+  # @return [Boolean, nil]
+  attr_accessor :original
+
+  def self.precision
+    Thread.current[:sass_numeric_precision] || Thread.main[:sass_numeric_precision] || 10
+  end
+
+  # Sets the number of digits of precision
+  # For example, if this is `3`,
+  # `3.1415926` will be printed as `3.142`.
+  # The numeric precision is stored as a thread local for thread safety reasons.
+  # To set for all threads, be sure to set the precision on the main thread.
+  def self.precision=(digits)
+    Thread.current[:sass_numeric_precision] = digits.round
+    Thread.current[:sass_numeric_precision_factor] = nil
+    Thread.current[:sass_numeric_epsilon] = nil
+  end
+
+  # the precision factor used in numeric output
+  # it is derived from the `precision` method.
+  def self.precision_factor
+    Thread.current[:sass_numeric_precision_factor] ||= 10.0**precision
+  end
+
+  # Used in checking equality of floating point numbers. Any
+  # numbers within an `epsilon` of each other are considered functionally equal.
+  # The value for epsilon is one tenth of the current numeric precision.
+  def self.epsilon
+    Thread.current[:sass_numeric_epsilon] ||= 1 / (precision_factor * 10)
+  end
+
+  # Used so we don't allocate two new arrays for each new number.
+  NO_UNITS = []
+
+  # @param value [Numeric] The value of the number
+  # @param numerator_units [::String, Array<::String>] See \{#numerator\_units}
+  # @param denominator_units [::String, Array<::String>] See \{#denominator\_units}
+  def initialize(value, numerator_units = NO_UNITS, denominator_units = NO_UNITS)
+    numerator_units = [numerator_units] if numerator_units.is_a?(::String)
+    denominator_units = [denominator_units] if denominator_units.is_a?(::String)
+    super(value)
+    @numerator_units = numerator_units
+    @denominator_units = denominator_units
+    @options = nil
+    normalize!
+  end
+
+  def hash
+    [value, numerator_units, denominator_units].hash
+  end
+
+  # Hash-equality works differently than `==` equality for numbers.
+  # Hash-equality must be transitive, so it just compares the exact value,
+  # numerator units, and denominator units.
+  def eql?(other)
+    basically_equal?(value, other.value) && numerator_units == other.numerator_units &&
+      denominator_units == other.denominator_units
+  end
+
+  # @return [String] The CSS representation of this number
+  # @raise [Sass::SyntaxError] if this number has units that can't be used in CSS
+  #   (e.g. `px*in`)
+  def to_s(opts = {})
+    return original if original
+    raise Sass::SyntaxError.new("#{inspect} isn't a valid CSS value.") unless legal_units?
+    inspect
+  end
+
+  # Returns a readable representation of this number.
+  #
+  # This representation is valid CSS (and valid SassScript)
+  # as long as there is only one unit.
+  #
+  # @return [String] The representation
+  def inspect(opts = {})
+    return original if original
+
+    value = self.class.round(self.value)
+    str = value.to_s
+
+    # Ruby will occasionally print in scientific notation if the number is
+    # small enough. That's technically valid CSS, but it's not well-supported
+    # and confusing.
+    str = ("%0.#{self.class.precision}f" % value).gsub(/0*$/, '') if str.include?('e')
+
+    # Sometimes numeric formatting will result in a decimal number with a trailing zero (x.0)
+    if str =~ /(.*)\.0$/
+      str = $1
+    end
+
+    # We omit a leading zero before the decimal point in compressed mode.
+    if @options && options[:style] == :compressed
+      str.sub!(/^(-)?0\./, '\1.')
+    end
+
+    unitless? ? str : "#{str}#{unit_str}"
+  end
+  alias_method :to_sass, :inspect
+
+  # @return [Integer] The integer value of the number
+  # @raise [Sass::SyntaxError] if the number isn't an integer
+  def to_i
+    super unless int?
+    value.to_i
+  end
+
+  # @return [Boolean] Whether or not this number is an integer.
+  def int?
+    basically_equal?(value % 1, 0.0)
+  end
+
+  # @return [Boolean] Whether or not this number has no units.
+  def unitless?
+    @numerator_units.empty? && @denominator_units.empty?
+  end
+
+  # Checks whether the number has the numerator unit specified.
+  #
+  # @example
+  #   number = Sass::Script::Value::Number.new(10, "px")
+  #   number.is_unit?("px") => true
+  #   number.is_unit?(nil) => false
+  #
+  # @param unit [::String, nil] The unit the number should have or nil if the number
+  #   should be unitless.
+  # @see Number#unitless? The unitless? method may be more readable.
+  def is_unit?(unit)
+    if unit
+      denominator_units.size == 0 && numerator_units.size == 1 && numerator_units.first == unit
+    else
+      unitless?
+    end
+  end
+
+  # @return [Boolean] Whether or not this number has units that can be represented in CSS
+  #   (that is, zero or one \{#numerator\_units}).
+  def legal_units?
+    (@numerator_units.empty? || @numerator_units.size == 1) && @denominator_units.empty?
+  end
+
+  # Returns this number converted to other units.
+  # The conversion takes into account the relationship between e.g. mm and cm,
+  # as well as between e.g. in and cm.
+  #
+  # If this number has no units, it will simply return itself
+  # with the given units.
+  #
+  # An incompatible coercion, e.g. between px and cm, will raise an error.
+  #
+  # @param num_units [Array<String>] The numerator units to coerce this number into.
+  #   See {\#numerator\_units}
+  # @param den_units [Array<String>] The denominator units to coerce this number into.
+  #   See {\#denominator\_units}
+  # @return [Number] The number with the new units
+  # @raise [Sass::UnitConversionError] if the given units are incompatible with the number's
+  #   current units
+  def coerce(num_units, den_units)
+    Number.new(if unitless?
+                 value
+               else
+                 value * coercion_factor(@numerator_units, num_units) /
+                   coercion_factor(@denominator_units, den_units)
+               end, num_units, den_units)
+  end
+
+  # @param other [Number] A number to decide if it can be compared with this number.
+  # @return [Boolean] Whether or not this number can be compared with the other.
+  def comparable_to?(other)
+    operate(other, :+)
+    true
+  rescue Sass::UnitConversionError
+    false
+  end
+
+  # Returns a human readable representation of the units in this number.
+  # For complex units this takes the form of:
+  # numerator_unit1 * numerator_unit2 / denominator_unit1 * denominator_unit2
+  # @return [String] a string that represents the units in this number
+  def unit_str
+    rv = @numerator_units.sort.join("*")
+    if @denominator_units.any?
+      rv << "/"
+      rv << @denominator_units.sort.join("*")
+    end
+    rv
+  end
+
+  private
+
+  # @private
+  # @see Sass::Script::Number.basically_equal?
+  def basically_equal?(num1, num2)
+    self.class.basically_equal?(num1, num2)
+  end
+
+  # Checks whether two numbers are within an epsilon of each other.
+  # @return [Boolean]
+  def self.basically_equal?(num1, num2)
+    (num1 - num2).abs < epsilon
+  end
+
+  # @private
+  def self.round(num)
+    if num.is_a?(Float) && (num.infinite? || num.nan?)
+      num
+    elsif basically_equal?(num % 1, 0.0)
+      num.round
+    else
+      ((num * precision_factor).round / precision_factor).to_f
+    end
+  end
+
+  OPERATIONS = [:+, :-, :<=, :<, :>, :>=, :%]
+
+  def operate(other, operation)
+    this = self
+    if OPERATIONS.include?(operation)
+      if unitless?
+        this = this.coerce(other.numerator_units, other.denominator_units)
+      else
+        other = other.coerce(@numerator_units, @denominator_units)
+      end
+    end
+    # avoid integer division
+    value = :/ == operation ? this.value.to_f : this.value
+    result = value.send(operation, other.value)
+
+    if result.is_a?(Numeric)
+      Number.new(result, *compute_units(this, other, operation))
+    else # Boolean op
+      Bool.new(result)
+    end
+  end
+
+  def coercion_factor(from_units, to_units)
+    # get a list of unmatched units
+    from_units, to_units = sans_common_units(from_units, to_units)
+
+    if from_units.size != to_units.size || !convertable?(from_units | to_units)
+      raise Sass::UnitConversionError.new(
+        "Incompatible units: '#{from_units.join('*')}' and '#{to_units.join('*')}'.")
+    end
+
+    from_units.zip(to_units).inject(1) {|m, p| m * conversion_factor(p[0], p[1])}
+  end
+
+  def compute_units(this, other, operation)
+    case operation
+    when :*
+      [this.numerator_units + other.numerator_units,
+       this.denominator_units + other.denominator_units]
+    when :/
+      [this.numerator_units + other.denominator_units,
+       this.denominator_units + other.numerator_units]
+    else
+      [this.numerator_units, this.denominator_units]
+    end
+  end
+
+  def normalize!
+    return if unitless?
+    @numerator_units, @denominator_units =
+      sans_common_units(@numerator_units, @denominator_units)
+
+    @denominator_units.each_with_index do |d, i|
+      next unless convertable?(d) && (u = @numerator_units.find {|n| convertable?([n, d])})
+      @value /= conversion_factor(d, u)
+      @denominator_units.delete_at(i)
+      @numerator_units.delete_at(@numerator_units.index(u))
+    end
+  end
+
+  # This is the source data for all the unit logic. It's pre-processed to make
+  # it efficient to figure out whether a set of units is mutually compatible
+  # and what the conversion ratio is between two units.
+  #
+  # These come from http://www.w3.org/TR/2012/WD-css3-values-20120308/.
+  relative_sizes = [
+    {
+      "in"   => Rational(1),
+      "cm"   => Rational(1, 2.54),
+      "pc"   => Rational(1, 6),
+      "mm"   => Rational(1, 25.4),
+      "q"    => Rational(1, 101.6),
+      "pt"   => Rational(1, 72),
+      "px"   => Rational(1, 96)
+    },
+    {
+      "deg"  => Rational(1, 360),
+      "grad" => Rational(1, 400),
+      "rad"  => Rational(1, 2 * Math::PI),
+      "turn" => Rational(1)
+    },
+    {
+      "s"    => Rational(1),
+      "ms"   => Rational(1, 1000)
+    },
+    {
+      "Hz"   => Rational(1),
+      "kHz"  => Rational(1000)
+    },
+    {
+      "dpi"  => Rational(1),
+      "dpcm" => Rational(254, 100),
+      "dppx" => Rational(96)
+    }
+  ]
+
+  # A hash from each known unit to the set of units that it's mutually
+  # convertible with.
+  MUTUALLY_CONVERTIBLE = {}
+  relative_sizes.map do |values|
+    set = values.keys.to_set
+    values.keys.each {|name| MUTUALLY_CONVERTIBLE[name] = set}
+  end
+
+  # A two-dimensional hash from two units to the conversion ratio between
+  # them. Multiply `X` by `CONVERSION_TABLE[X][Y]` to convert it to `Y`.
+  CONVERSION_TABLE = {}
+  relative_sizes.each do |values|
+    values.each do |(name1, value1)|
+      CONVERSION_TABLE[name1] ||= {}
+      values.each do |(name2, value2)|
+        value = value1 / value2
+        CONVERSION_TABLE[name1][name2] = value.denominator == 1 ? value.to_i : value.to_f
+      end
+    end
+  end
+
+  def conversion_factor(from_unit, to_unit)
+    CONVERSION_TABLE[from_unit][to_unit]
+  end
+
+  def convertable?(units)
+    units = Array(units).to_set
+    return true if units.empty?
+    return false unless (mutually_convertible = MUTUALLY_CONVERTIBLE[units.first])
+    units.subset?(mutually_convertible)
+  end
+
+  def sans_common_units(units1, units2)
+    units2 = units2.dup
+    # Can't just use -, because we want px*px to coerce properly to px*mm
+    units1 = units1.map do |u|
+      j = units2.index(u)
+      next u unless j
+      units2.delete_at(j)
+      nil
+    end
+    units1.compact!
+    return units1, units2
+  end
+
+end