Class: Sass::Value::Number

Inherits:
Object
  • Object
show all
Includes:
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_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>) 


17
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
 
# File 'lib/sass/value/number.rb', line 17

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.freeze
  @denominator_units = denominator_units.freeze
end

Instance Attribute Details

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

Returns:

  • (Array<::String>) 


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

def denominator_units
  @denominator_units
end

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

Returns:

  • (Array<::String>) 


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

def numerator_units
  @numerator_units
end

#value ⇒ Numeric (readonly)

Returns:

  • (Numeric) 


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

def value
  @value
end

Instance Method Details

#==(other) ⇒ ::Boolean

Returns:

  • (::Boolean) 


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

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:



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

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

#assert_integer(name = nil) ⇒ Integer

Returns:

  • (Integer)

Raises:



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

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:



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

def assert_number(_name = nil)
  self
end

#assert_unit(unit, name = nil) ⇒ Number

Parameters:

  • unit (::String)

Returns:

Raises:



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

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:



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

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:



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

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:



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

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) 


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

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: name)
end

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

Parameters:

Returns:

  • (Numeric) 


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

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: name,
                          other: other,
                          other_name: other_name)
end

#coerce_value_to_unit(unit, name = nil) ⇒ Numeric

Parameters:

  • unit (::String)

Returns:

  • (Numeric) 


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

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

#compatible_with_unit?(unit) ⇒ ::Boolean

Parameters:

  • unit (::String)

Returns:

  • (::Boolean) 


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

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:



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

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:



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

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) 


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

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: name)
end

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

Parameters:

Returns:

  • (Numeric) 


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

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: name,
                          other: other,
                          other_name: other_name)
end

#hash ⇒ Integer

Returns:

  • (Integer) 


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

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

#integer? ⇒ ::Boolean

Returns:

  • (::Boolean) 


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

def integer?
  FuzzyMath.integer?(value)
end

#to_i ⇒ Integer

Returns:

  • (Integer) 


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

def to_i
  FuzzyMath.to_i(value)
end

#unit?(unit) ⇒ ::Boolean

Parameters:

  • unit (::String)

Returns:

  • (::Boolean) 


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

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

#unitless? ⇒ ::Boolean

Returns:

  • (::Boolean) 


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

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

#units? ⇒ ::Boolean

Returns:

  • (::Boolean) 


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

def units?
  !unitless?
end