10728217744

Committed 05 Sep 2024 09:07PM UTC coverage: 58.013% (-4.5%) from 62.464%

Build # 10728217744

Build Type

push

github

Committed by

alerque

Commit Message

refactor(cli): Satiate clippy's new "never type fallback" lint

New in Rust 1.81.0, scheduled to be an error in edition 2024:

https://github.com/rust-lang/rust/issues/123748

It looks like mlua v0.10 won't need this workaround:

https://github.com/mlua-rs/mlua/commit/3641c9895

Run Details

10103 of 17415 relevant lines covered (58.01%)

1419.94 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

83.5

/types/measurement.lua

--- SILE measurement type.
-- Measurements consist of an amount and a unit. Any registered `types.unit` may be used. Some units are relative and
-- their value may depend on the context where they are evaluated. Others are absolute. Unlike `types.length`
-- measurements have no stretch or shrink parameters.
-- @types measurement

local function _tonumber (amount)
   return SU.cast("number", amount)
end

local function _similarunit (a, b)
   if type(b) == "number" or type(a) == "number" then
      return true
   else
      return a.unit == b.unit
   end
end

local function _hardnumber (a, b)
   if type(b) == "number" or type(a) == "number" then
      return true
   else
      return false
   end
end

local function _unit (a, b)
   return type(a) == "table" and a.unit or b.unit
end

local function _amount (input)
   return type(input) == "number" and input or input.amount
end

local function _pt_amount (input)
   return type(input) == "number" and input or not input and 0 or input._mutable and input.amount or input:tonumber()
end

local function _error_if_immutable (input)
   if type(input) == "table" and not input._mutable then
      SU.error("Not so fast, we can't do mutating arithmetic except on 'pt' unit measurements!", true)
   end
end

local function _error_if_relative (a, b)
   if type(a) == "table" and a.relative or type(b) == "table" and b.relative then
      SU.error("Cannot do arithmetic on a relative measurement without explicitly absolutizing it.", true)
   end
end

--- @type measurement
local measurement = pl.class()
measurement.type = "measurement"

measurement.amount = 0
measurement.unit = "pt"
measurement.relative = false
measurement._mutable = false

--- Constructor.
-- @tparam number|length|measurement|string amount Amount of units or a string with the amount and unit.
-- @tparam[opt=pt] string unit Name of unit.
-- @treturn measurement
-- @usage
-- SILE.types.measurement(3, "em")
-- SILE.types.measurement("2%fw")
-- SILE.types.measurement(6)
function measurement:_init (amount, unit)
   if unit then
      self.unit = unit
   end
   if SU.type(amount) == "length" then
      self.amount = amount.length.amount
      self.unit = amount.length.unit
   elseif type(amount) == "table" then
      self.amount = amount.amount
      self.unit = amount.unit
   elseif type(tonumber(amount)) == "number" then
      self.amount = tonumber(amount)
   elseif type(amount) == "string" then
      local parsed = SILE.parserBits.measurement:match(amount)
      if not parsed then
         SU.error("Could not parse measurement '" .. amount .. "'")
      end
      self.amount, self.unit = parsed.amount, parsed.unit
   end
   local _su = SILE.types.unit[self.unit]
   if not _su then
      SU.error("Unknown unit: " .. unit)
   end
   self.relative = _su.relative
   if self.unit == "pt" then
      self._mutable = true
   end
end

--- Convert relative measurements to absolute values and return a measurement.
-- Resolves relative measurements (like em relevant to the current font size) into absolute measurements.
-- @treturn measurement A new measurement in pt with any relative values resolved.
-- @usage
-- > a = SILE.types.measurement("1.2em")
-- > print(a:absolute())
-- 12pt
function measurement:absolute ()
   return SILE.types.measurement(self:tonumber())
end

function measurement:tostring ()
   return self:__tostring()
end

--- Convert relative measurements to absolute values and return a number.
-- Similar to `measurement:absolute` but returns a number instead of a new measurement type.
-- @treturn number A number (corresponding to pts) for the amount with any relative values resolved.
function measurement:tonumber ()
   local def = SILE.types.unit[self.unit]
   local amount = def.converter and def.converter(self.amount) or (self.amount * def.value)
   return amount
end

function measurement:__tostring ()
   return self.amount .. self.unit
end

function measurement:__concat (other)
   return tostring(self) .. tostring(other)
end

--- Addition meta-method.
-- Assuming matching relative units or absolute units, allows two measurements to be combined into one.
-- @tparam measurement other
-- @treturn measuremnet A new measurement of the same unit type as `self` with the value of `other` added.
-- @usage
-- > a = SILE.types.measurement(6, "em")
-- > b = SILE.types.measurement("2em")
-- > c = a + b
-- > print(c)
-- 8em
function measurement:__add (other)
   if _similarunit(self, other) then
      return SILE.types.measurement(_amount(self) + _amount(other), _unit(self, other))
   else
      _error_if_relative(self, other)
      return SILE.types.measurement(_tonumber(self) + _tonumber(other))
   end
end

-- Note all private math (_ + __func()) functions:
-- * Are much faster than regular math operations
-- * Are **not** intended for use outside of the most performance sensitive loops
-- * Modify the lhs input in-place, never instantiating new objects
-- * Always assume absolute lhs input and absolutize the rhs values at runtime
-- * Assmue the inputs are sane with much less error checking than regular math funcs
-- * Are not composable using chained methods since they return nil for safety
function measurement:___add (other)
   _error_if_immutable(self)
   self.amount = self.amount + _pt_amount(other)
   return nil
end

function measurement:__sub (other)
   if _similarunit(self, other) then
      return SILE.types.measurement(_amount(self) - _amount(other), _unit(self, other))
   else
      _error_if_relative(self, other)
      return SILE.types.measurement(_tonumber(self) - _tonumber(other))
   end
end

-- See usage comments on SILE.types.measurement:___add()
function measurement:___sub (other)
   _error_if_immutable(self)
   self.amount = self.amount - _pt_amount(other)
   return nil
end

function measurement:__mul (other)
   if _hardnumber(self, other) then
      return SILE.types.measurement(_amount(self) * _amount(other), _unit(self, other))
   else
      _error_if_relative(self, other)
      return SILE.types.measurement(_tonumber(self) * _tonumber(other))
   end
end

function measurement:__pow (other)
   if _hardnumber(self, other) then
      return SILE.types.measurement(_amount(self) ^ _amount(other), self.unit)
   else
      _error_if_relative(self, other)
      return SILE.types.measurement(_tonumber(self) ^ _tonumber(other))
   end
end

function measurement:__div (other)
   if _hardnumber(self, other) then
      return SILE.types.measurement(_amount(self) / _amount(other), self.unit)
   else
      _error_if_relative(self, other)
      return SILE.types.measurement(_tonumber(self) / _tonumber(other))
   end
end

function measurement:__mod (other)
   if _hardnumber(self, other) then
      return SILE.types.measurement(_amount(self) % _amount(other), self.unit)
   else
      _error_if_relative(self, other)
      return SILE.types.measurement(_tonumber(self) % _tonumber(other))
   end
end

function measurement:__unm ()
   local ret = SILE.types.measurement(self)
   ret.amount = self.amount * -1
   return ret
end

function measurement:__eq (other)
   return _tonumber(self) == _tonumber(other)
end

function measurement:__lt (other)
   return _tonumber(self) < _tonumber(other)
end

function measurement:__le (other)
   return _tonumber(self) <= _tonumber(other)
end

return measurement

1	--- SILE measurement type.
2	-- Measurements consist of an amount and a unit. Any registered `types.unit` may be used. Some units are relative and
3	-- their value may depend on the context where they are evaluated. Others are absolute. Unlike `types.length`
4	-- measurements have no stretch or shrink parameters.
5	-- @types measurement
6
7	local function _tonumber (amount)
8	return SU.cast("number", amount)	8,052✔
9	end
10
11	local function _similarunit (a, b)
12	if type(b) == "number" or type(a) == "number" then	32,986✔
13	return true	2,474✔
14	else
15	return a.unit == b.unit	30,512✔
16	end
17	end
18
19	local function _hardnumber (a, b)
20	if type(b) == "number" or type(a) == "number" then	2,644✔
21	return true	2,404✔
22	else
23	return false	240✔
24	end
25	end
26
27	local function _unit (a, b)
28	return type(a) == "table" and a.unit or b.unit	31,636✔
29	end
30
31	local function _amount (input)
32	return type(input) == "number" and input or input.amount	63,302✔
33	end
34
35	local function _pt_amount (input)
36	return type(input) == "number" and input or not input and 0 or input._mutable and input.amount or input:tonumber()	48,487✔
37	end
38
39	local function _error_if_immutable (input)
40	if type(input) == "table" and not input._mutable then	48,364✔
41	SU.error("Not so fast, we can't do mutating arithmetic except on 'pt' unit measurements!", true)	×
42	end
43	end
44
45	local function _error_if_relative (a, b)
46	if type(a) == "table" and a.relative or type(b) == "table" and b.relative then	3,979✔
47	SU.error("Cannot do arithmetic on a relative measurement without explicitly absolutizing it.", true)	×
48	end
49	end
50
51	--- @type measurement
52	local measurement = pl.class()	41✔
53	measurement.type = "measurement"	41✔
54
55	measurement.amount = 0	41✔
56	measurement.unit = "pt"	41✔
57	measurement.relative = false	41✔
58	measurement._mutable = false	41✔
59
60	--- Constructor.
61	-- @tparam number\|length\|measurement\|string amount Amount of units or a string with the amount and unit.
62	-- @tparam[opt=pt] string unit Name of unit.
63	-- @treturn measurement
64	-- @usage
65	-- SILE.types.measurement(3, "em")
66	-- SILE.types.measurement("2%fw")
67	-- SILE.types.measurement(6)
68	function measurement:_init (amount, unit)	41✔
69	if unit then	195,603✔
70	self.unit = unit	31,695✔
71	end
72	if SU.type(amount) == "length" then	391,206✔
73	self.amount = amount.length.amount	×
74	self.unit = amount.length.unit	×
75	elseif type(amount) == "table" then	195,603✔
76	self.amount = amount.amount	38,298✔
77	self.unit = amount.unit	38,298✔
78	elseif type(tonumber(amount)) == "number" then	157,305✔
79	self.amount = tonumber(amount)	74,657✔
80	elseif type(amount) == "string" then	82,648✔
81	local parsed = SILE.parserBits.measurement:match(amount)	38✔
82	if not parsed then	38✔
83	SU.error("Could not parse measurement '" .. amount .. "'")	×
84	end
85	self.amount, self.unit = parsed.amount, parsed.unit	38✔
86	end
87	local _su = SILE.types.unit[self.unit]	195,644✔
88	if not _su then	195,603✔
89	SU.error("Unknown unit: " .. unit)	×
90	end
91	self.relative = _su.relative	195,603✔
92	if self.unit == "pt" then	195,603✔
93	self._mutable = true	194,366✔
94	end
95	end
96
97	--- Convert relative measurements to absolute values and return a measurement.
98	-- Resolves relative measurements (like em relevant to the current font size) into absolute measurements.
99	-- @treturn measurement A new measurement in pt with any relative values resolved.
100	-- @usage
101	-- > a = SILE.types.measurement("1.2em")
102	-- > print(a:absolute())
103	-- 12pt
104	function measurement:absolute ()	41✔
105	return SILE.types.measurement(self:tonumber())	772✔
106	end
107
108	function measurement:tostring ()	41✔
109	return self:__tostring()	×
110	end
111
112	--- Convert relative measurements to absolute values and return a number.
113	-- Similar to `measurement:absolute` but returns a number instead of a new measurement type.
114	-- @treturn number A number (corresponding to pts) for the amount with any relative values resolved.
115	function measurement:tonumber ()	41✔
116	local def = SILE.types.unit[self.unit]	70,958✔
117	local amount = def.converter and def.converter(self.amount) or (self.amount * def.value)	71,959✔
118	return amount	70,958✔
119	end
120
121	function measurement:__tostring ()	41✔
122	return self.amount .. self.unit	13✔
123	end
124
125	function measurement:__concat (other)	41✔
126	return tostring(self) .. tostring(other)	8✔
127	end
128
129	--- Addition meta-method.
130	-- Assuming matching relative units or absolute units, allows two measurements to be combined into one.
131	-- @tparam measurement other
132	-- @treturn measuremnet A new measurement of the same unit type as `self` with the value of `other` added.
133	-- @usage
134	-- > a = SILE.types.measurement(6, "em")
135	-- > b = SILE.types.measurement("2em")
136	-- > c = a + b
137	-- > print(c)
138	-- 8em
139	function measurement:__add (other)	41✔
140	if _similarunit(self, other) then	29,860✔
141	return SILE.types.measurement(_amount(self) + _amount(other), _unit(self, other))	59,700✔
142	else
143	_error_if_relative(self, other)	5✔
144	return SILE.types.measurement(_tonumber(self) + _tonumber(other))	15✔
145	end
146	end
147
148	-- Note all private math (_ + __func()) functions:
149	-- * Are much faster than regular math operations
150	-- * Are not intended for use outside of the most performance sensitive loops
151	-- * Modify the lhs input in-place, never instantiating new objects
152	-- * Always assume absolute lhs input and absolutize the rhs values at runtime
153	-- * Assmue the inputs are sane with much less error checking than regular math funcs
154	-- * Are not composable using chained methods since they return nil for safety
155	function measurement:___add (other)	41✔
156	_error_if_immutable(self)	45,565✔
157	self.amount = self.amount + _pt_amount(other)	91,130✔
158	return nil	45,565✔
159	end
160
161	function measurement:__sub (other)	41✔
162	if _similarunit(self, other) then	36,112✔
163	return SILE.types.measurement(_amount(self) - _amount(other), _unit(self, other))	57,288✔
164	else
165	_error_if_relative(self, other)	3,734✔
166	return SILE.types.measurement(_tonumber(self) - _tonumber(other))	11,202✔
167	end
168	end
169
170	-- See usage comments on SILE.types.measurement:___add()
171	function measurement:___sub (other)	41✔
172	_error_if_immutable(self)	2,799✔
173	self.amount = self.amount - _pt_amount(other)	5,598✔
174	return nil	2,799✔
175	end
176
177	function measurement:__mul (other)	41✔
178	if _hardnumber(self, other) then	4,780✔
179	return SILE.types.measurement(_amount(self) * _amount(other), _unit(self, other))	9,556✔
180	else
181	_error_if_relative(self, other)	1✔
182	return SILE.types.measurement(_tonumber(self) * _tonumber(other))	3✔
183	end
184	end
185
186	function measurement:__pow (other)	41✔
187	if _hardnumber(self, other) then	×
188	return SILE.types.measurement(_amount(self) ^ _amount(other), self.unit)	×
189	else
190	_error_if_relative(self, other)	×
191	return SILE.types.measurement(_tonumber(self) ^ _tonumber(other))	×
192	end
193	end
194
195	function measurement:__div (other)	41✔
196	if _hardnumber(self, other) then	508✔
197	return SILE.types.measurement(_amount(self) / _amount(other), self.unit)	45✔
198	else
199	_error_if_relative(self, other)	239✔
200	return SILE.types.measurement(_tonumber(self) / _tonumber(other))	717✔
201	end
202	end
203
204	function measurement:__mod (other)	41✔
205	if _hardnumber(self, other) then	×
206	return SILE.types.measurement(_amount(self) % _amount(other), self.unit)	×
207	else
208	_error_if_relative(self, other)	×
209	return SILE.types.measurement(_tonumber(self) % _tonumber(other))	×
210	end
211	end
212
213	function measurement:__unm ()	41✔
214	local ret = SILE.types.measurement(self)	23✔
215	ret.amount = self.amount * -1	23✔
216	return ret	23✔
217	end
218
219	function measurement:__eq (other)	41✔
220	return _tonumber(self) == _tonumber(other)	×
221	end
222
223	function measurement:__lt (other)	41✔
224	return _tonumber(self) < _tonumber(other)	141✔
225	end
226
227	function measurement:__le (other)	41✔
228	return _tonumber(self) <= _tonumber(other)	×
229	end
230
231	return measurement	41✔

sile-typesetter / sile / 10728217744

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous