Class: Sass::Value::Number

Inherits:
Object
  • Object
show all
Includes:
CalculationValue, Sass::Value
Defined in:
lib/sass/value/number.rb,
lib/sass/value/number/unit.rb

Overview

Sass’s number type.

See Also:

Instance Attribute Summary collapse

Instance Method Summary collapse

Methods included from Sass::Value

#[], #assert_boolean, #assert_calculation, #assert_color, #assert_function, #assert_map, #assert_mixin, #assert_string, #at, #bracketed?, #eql?, #sass_index_to_array_index, #separator, #to_a, #to_bool, #to_map, #to_nil

Constructor Details

#initialize(value, unit = nil) ⇒ Number

Returns a new instance of Number.

Parameters:

  • value (Numeric)
  • unit (::String, Hash) (defaults to: nil)

Options Hash (unit):

  • :numerator_units (Array<::String>)
  • :denominator_units (Array<::String>) 


18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
 
# File 'lib/sass/value/number.rb', line 18

def initialize(value, unit = nil)
  case unit
  when nil
    numerator_units = []
    denominator_units = []
  when ::String
    numerator_units = [unit]
    denominator_units = []
  when ::Hash
    numerator_units = unit.fetch(:numerator_units, [])
    unless numerator_units.is_a?(Array)
      raise Sass::ScriptError, "invalid numerator_units #{numerator_units.inspect}"
    end

    denominator_units = unit.fetch(:denominator_units, [])
    unless denominator_units.is_a?(Array)
      raise Sass::ScriptError, "invalid denominator_units #{denominator_units.inspect}"
    end
  else
    raise Sass::ScriptError, "invalid unit #{unit.inspect}"
  end

  unless denominator_units.empty? && numerator_units.empty?
    value = value.dup
    numerator_units = numerator_units.dup
    new_denominator_units = []

    denominator_units.each do |denominator_unit|
      index = numerator_units.find_index do |numerator_unit|
        factor = Unit.conversion_factor(denominator_unit, numerator_unit)
        if factor.nil?
          false
        else
          value *= factor
          true
        end
      end
      if index.nil?
        new_denominator_units.push(denominator_unit)
      else
        numerator_units.delete_at(index)
      end
    end

    denominator_units = new_denominator_units
  end

  @value = value.freeze
  @numerator_units = numerator_units.each(&:freeze).freeze
  @denominator_units = denominator_units.each(&:freeze).freeze
end

Instance Attribute Details

#denominator_units ⇒ Array<::String> (readonly)

Returns:

  • (Array<::String>) 


74
75
76
 
# File 'lib/sass/value/number.rb', line 74

def denominator_units
  @denominator_units
end

#numerator_units ⇒ Array<::String> (readonly)

Returns:

  • (Array<::String>) 


74
75
76
 
# File 'lib/sass/value/number.rb', line 74

def numerator_units
  @numerator_units
end

#value ⇒ Numeric (readonly)

Returns:

  • (Numeric) 


71
72
73
 
# File 'lib/sass/value/number.rb', line 71

def value
  @value
end

Instance Method Details

#==(other) ⇒ ::Boolean

Returns:

  • (::Boolean) 


77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
 
# File 'lib/sass/value/number.rb', line 77

def ==(other)
  return false unless other.is_a?(Sass::Value::Number)

  return false if numerator_units.length != other.numerator_units.length ||
                  denominator_units.length != other.denominator_units.length

  return FuzzyMath.equals(value, other.value) if unitless?

  if Unit.canonicalize_units(numerator_units) != Unit.canonicalize_units(other.numerator_units) &&
     Unit.canonicalize_units(denominator_units) != Unit.canonicalize_units(other.denominator_units)
    return false
  end

  FuzzyMath.equals(
    (value *
    Unit.canonical_multiplier(numerator_units) /
    Unit.canonical_multiplier(denominator_units)),
    (other.value *
    Unit.canonical_multiplier(other.numerator_units) /
    Unit.canonical_multiplier(other.denominator_units))
  )
end

#assert_between(min, max, name = nil) ⇒ Numeric

Parameters:

  • min (Numeric)
  • max (Numeric)

Returns:

  • (Numeric)

Raises:



160
161
162
 
# File 'lib/sass/value/number.rb', line 160

def assert_between(min, max, name = nil)
  FuzzyMath.assert_between(value, min, max, name)
end

#assert_integer(name = nil) ⇒ Integer

Returns:

  • (Integer)

Raises:



145
146
147
148
149
 
# File 'lib/sass/value/number.rb', line 145

def assert_integer(name = nil)
  raise Sass::ScriptError.new("#{self} is not an integer", name) unless integer?

  to_i
end

#assert_number(_name = nil) ⇒ Number

Returns:



253
254
255
 
# File 'lib/sass/value/number.rb', line 253

def assert_number(_name = nil)
  self
end

#assert_unit(unit, name = nil) ⇒ Number

Parameters:

  • unit (::String)

Returns:

Raises:



132
133
134
135
136
 
# File 'lib/sass/value/number.rb', line 132

def assert_unit(unit, name = nil)
  raise Sass::ScriptError.new("Expected #{self} to have unit #{unit.inspect}", name) unless unit?(unit)

  self
end

#assert_unitless(name = nil) ⇒ Number

Returns:

Raises:



112
113
114
115
116
 
# File 'lib/sass/value/number.rb', line 112

def assert_unitless(name = nil)
  raise Sass::ScriptError.new("Expected #{self} to have no units", name) unless unitless?

  self
end

#coerce(new_numerator_units, new_denominator_units, name = nil) ⇒ Number

Parameters:

  • new_numerator_units (Array<::String>)
  • new_denominator_units (Array<::String>)

Returns:



211
212
213
214
215
216
 
# File 'lib/sass/value/number.rb', line 211

def coerce(new_numerator_units, new_denominator_units, name = nil)
  Number.new(coerce_value(new_numerator_units, new_denominator_units, name), {
               numerator_units: new_numerator_units,
               denominator_units: new_denominator_units
             })
end

#coerce_to_match(other, name = nil, other_name = nil) ⇒ Number

Parameters:

Returns:



235
236
237
238
239
240
 
# File 'lib/sass/value/number.rb', line 235

def coerce_to_match(other, name = nil, other_name = nil)
  Number.new(coerce_value_to_match(other, name, other_name), {
               numerator_units: other.numerator_units,
               denominator_units: other.denominator_units
             })
end

#coerce_value(new_numerator_units, new_denominator_units, name = nil) ⇒ Numeric

Parameters:

  • new_numerator_units (Array<::String>)
  • new_denominator_units (Array<::String>)

Returns:

  • (Numeric) 


221
222
223
224
225
 
# File 'lib/sass/value/number.rb', line 221

def coerce_value(new_numerator_units, new_denominator_units, name = nil)
  coerce_or_convert_value(new_numerator_units, new_denominator_units,
                          coerce_unitless: true,
                          name:)
end

#coerce_value_to_match(other, name = nil, other_name = nil) ⇒ Numeric

Parameters:

Returns:

  • (Numeric) 


244
245
246
247
248
249
250
 
# File 'lib/sass/value/number.rb', line 244

def coerce_value_to_match(other, name = nil, other_name = nil)
  coerce_or_convert_value(other.numerator_units, other.denominator_units,
                          coerce_unitless: true,
                          name:,
                          other:,
                          other_name:)
end

#coerce_value_to_unit(unit, name = nil) ⇒ Numeric

Parameters:

  • unit (::String)

Returns:

  • (Numeric) 


229
230
231
 
# File 'lib/sass/value/number.rb', line 229

def coerce_value_to_unit(unit, name = nil)
  coerce_value([unit], [], name)
end

#compatible_with_unit?(unit) ⇒ ::Boolean

Parameters:

  • unit (::String)

Returns:

  • (::Boolean) 


166
167
168
 
# File 'lib/sass/value/number.rb', line 166

def compatible_with_unit?(unit)
  single_unit? && !Unit.conversion_factor(numerator_units.first, unit).nil?
end

#convert(new_numerator_units, new_denominator_units, name = nil) ⇒ Number

Parameters:

  • new_numerator_units (Array<::String>)
  • new_denominator_units (Array<::String>)

Returns:



173
174
175
176
177
178
 
# File 'lib/sass/value/number.rb', line 173

def convert(new_numerator_units, new_denominator_units, name = nil)
  Number.new(convert_value(new_numerator_units, new_denominator_units, name), {
               numerator_units: new_numerator_units,
               denominator_units: new_denominator_units
             })
end

#convert_to_match(other, name = nil, other_name = nil) ⇒ Number

Parameters:

Returns:



191
192
193
194
195
196
 
# File 'lib/sass/value/number.rb', line 191

def convert_to_match(other, name = nil, other_name = nil)
  Number.new(convert_value_to_match(other, name, other_name), {
               numerator_units: other.numerator_units,
               denominator_units: other.denominator_units
             })
end

#convert_value(new_numerator_units, new_denominator_units, name = nil) ⇒ Numeric

Parameters:

  • new_numerator_units (Array<::String>)
  • new_denominator_units (Array<::String>)

Returns:

  • (Numeric) 


183
184
185
186
187
 
# File 'lib/sass/value/number.rb', line 183

def convert_value(new_numerator_units, new_denominator_units, name = nil)
  coerce_or_convert_value(new_numerator_units, new_denominator_units,
                          coerce_unitless: false,
                          name:)
end

#convert_value_to_match(other, name = nil, other_name = nil) ⇒ Numeric

Parameters:

Returns:

  • (Numeric) 


200
201
202
203
204
205
206
 
# File 'lib/sass/value/number.rb', line 200

def convert_value_to_match(other, name = nil, other_name = nil)
  coerce_or_convert_value(other.numerator_units, other.denominator_units,
                          coerce_unitless: false,
                          name:,
                          other:,
                          other_name:)
end

#hash ⇒ Integer

Returns:

  • (Integer) 


101
102
103
 
# File 'lib/sass/value/number.rb', line 101

def hash
  @hash ||= FuzzyMath.hash(canonical_units_value)
end

#integer? ⇒ ::Boolean

Returns:

  • (::Boolean) 


139
140
141
 
# File 'lib/sass/value/number.rb', line 139

def integer?
  FuzzyMath.integer?(value)
end

#to_i ⇒ Integer

Returns:

  • (Integer) 


152
153
154
 
# File 'lib/sass/value/number.rb', line 152

def to_i
  FuzzyMath.to_i(value)
end

#unit?(unit) ⇒ ::Boolean

Parameters:

  • unit (::String)

Returns:

  • (::Boolean) 


125
126
127
 
# File 'lib/sass/value/number.rb', line 125

def unit?(unit)
  single_unit? && numerator_units.first == unit
end

#unitless? ⇒ ::Boolean

Returns:

  • (::Boolean) 


106
107
108
 
# File 'lib/sass/value/number.rb', line 106

def unitless?
  numerator_units.empty? && denominator_units.empty?
end

#units? ⇒ ::Boolean

Returns:

  • (::Boolean) 


119
120
121
 
# File 'lib/sass/value/number.rb', line 119

def units?
  !unitless?
end