11135083927

Committed 01 Oct 2024 11:26PM UTC coverage: 62.071% (-7.3%) from 69.333%

Build # 11135083927

Build Type

push

github

Committed by

alerque

Commit Message

style: Reformat Lua with stylua

Run Details

0 of 9 new or added lines in 2 files covered. (0.0%)

1678 existing lines in 57 files now uncovered.

11071 of 17836 relevant lines covered (62.07%)

5220.48 hits per line

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

93.27

/packages/parallel/init.lua

local base = require("packages.base")

local package = pl.class(base)
package._name = "parallel"

local typesetterPool = {}
local calculations = {}
local folioOrder = {}

local allTypesetters = function (callback)
   local oldtypesetter = SILE.typesetter
   for frame, typesetter in pairs(typesetterPool) do
      SILE.typesetter = typesetter
      callback(frame, typesetter)
   end
   SILE.typesetter = oldtypesetter
end

local nulTypesetter = pl.class(SILE.typesetters.base) -- we ignore this
nulTypesetter.outputLinesToPage = function () end

local parallelPagebreak = function ()
   for i = 1, #folioOrder do
      local thisPageFrames = folioOrder[i]
      for j = 1, #thisPageFrames do
         local frame = thisPageFrames[j]
         local typesetter = typesetterPool[frame]
         local thispage = {}
         SU.debug("parallel", "Dumping lines for page on typesetter", typesetter.id)
         if #typesetter.state.outputQueue > 0 and calculations[frame].mark == 0 then
            -- More than one page worth of stuff here.
            -- Just ship out one page and hope for the best.
            SILE.typesetters.base.buildPage(typesetter)
         else
            for l = 1, calculations[frame].mark do
               thispage[l] = table.remove(typesetter.state.outputQueue, 1)
               SU.debug("parallel", thispage[l])
            end
            typesetter:outputLinesToPage(thispage)
         end
      end
      SILE.documentState.documentClass:endPage()
      for l = 1, #thisPageFrames do
         local frame = thisPageFrames[l]
         local typesetter = typesetterPool[frame]
         typesetter:initFrame(typesetter.frame)
      end
      SILE.documentState.documentClass:newPage()
   end
end

local addBalancingGlue = function (height)
   allTypesetters(function (frame, typesetter)
      local glue = height - calculations[frame].heightOfNewMaterial
      if glue.length:tonumber() > 0 then
         SU.debug("parallel", "Adding", glue, "to", frame)
         typesetter:pushVglue({ height = glue })
      end
      calculations[frame].mark = #typesetter.state.outputQueue
   end)
end

function package:_init (options)
   base._init(self, options)
   SILE.typesetter = nulTypesetter(SILE.getFrame("page"))
   if type(options.frames) ~= "table" then
      SU.error([[
         Package parallel must be initialized with a set of appropriately named frames

         This package is usually intended to be loaded from some supporting class or
         from another package, responsible for correct initialization.
      ]])
   end
   for frame, typesetter in pairs(options.frames) do
      typesetterPool[frame] = SILE.typesetters.base(SILE.getFrame(typesetter))
      typesetterPool[frame].id = typesetter
      typesetterPool[frame].buildPage = function ()
         -- No thank you, I will do that.
      end
      -- Fixed leading here is obviously a bug, but n-way leading calculations
      -- get very complicated...
      -- typesetterPool[frame].leadingFor = function() return SILE.types.node.vglue(SILE.settings:get("document.lineskip")) end
      local fontcommand = frame .. ":font"
      self:registerCommand(frame, function (_, _) -- \left ...
         SILE.typesetter = typesetterPool[frame]
         SILE.call(fontcommand)
      end)
      if not SILE.Commands[fontcommand] then
         self:registerCommand(fontcommand, function (_, _) end) -- to be overridden
      end
   end
   if not options.folios then
      folioOrder = { {} }
      -- Note output order doesn't matter for PDF, but for our test suite it is
      -- essential that the output order is deterministic, hence this sort()
      for frame, _ in pl.tablex.sort(options.frames) do
         table.insert(folioOrder[1], frame)
      end
   else
      folioOrder = options.folios -- As usual we trust the user knows what they're doing
   end
   self.class.newPage = function (self_)
      allTypesetters(function (frame, _)
         calculations[frame] = { mark = 0 }
      end)
      self.class._base.newPage(self_)
      SILE.call("sync")
   end
   allTypesetters(function (frame, _)
      calculations[frame] = { mark = 0 }
   end)
   local oldfinish = self.class.finish
   self.class.finish = function (self_)
      parallelPagebreak()
      oldfinish(self_)
   end
end

function package:registerCommands ()
   self:registerCommand("sync", function (_, _)
      local anybreak = false
      local maxheight = SILE.types.length()
      SU.debug("parallel", "Trying a sync")
      allTypesetters(function (_, typesetter)
         SU.debug("parallel", "Leaving hmode on", typesetter.id)
         typesetter:leaveHmode(true)
         -- Now we have each typesetter's content boxed up onto the output stream
         -- but page breaking has not been run. See if page breaking would cause a
         -- break
         local lines = pl.tablex.copy(typesetter.state.outputQueue)
         if SILE.pagebuilder:findBestBreak({ vboxlist = lines, target = typesetter:getTargetLength() }) then
            anybreak = true
         end
      end)

      if anybreak then
         parallelPagebreak()
         return
      end

      allTypesetters(function (frame, typesetter)
         calculations[frame].heightOfNewMaterial = SILE.types.length()
         for i = calculations[frame].mark + 1, #typesetter.state.outputQueue do
            local thisHeight = typesetter.state.outputQueue[i].height + typesetter.state.outputQueue[i].depth
            calculations[frame].heightOfNewMaterial = calculations[frame].heightOfNewMaterial + thisHeight
         end
         if maxheight < calculations[frame].heightOfNewMaterial then
            maxheight = calculations[frame].heightOfNewMaterial
         end
         SU.debug(
            "parallel",
            frame,
            ": pre-sync content=",
            calculations[frame].mark,
            ", now",
            #typesetter.state.outputQueue,
            ", height of material:",
            calculations[frame].heightOfNewMaterial
         )
      end)
      addBalancingGlue(maxheight)
   end)
end

package.documentation = [[
\begin{document}
The \autodoc:package{parallel} package provides the mechanism for typesetting diglot or other parallel documents.
When used by a class such as \code{classes/diglot.lua}, it registers a command for each parallel frame, to allow you to select which frame you’re typesetting into.
It also defines the \autodoc:command{\sync} command, which adds vertical spacing to each frame such that the \em{next} set of text is vertically aligned.
See \url{https://sile-typesetter.org/examples/parallel.sil} and the source of \code{classes/diglot.lua} for examples which make the operation clear.
\end{document}
]]

return package

1	local base = require("packages.base")	1✔
2
3	local package = pl.class(base)	1✔
4	package._name = "parallel"	1✔
5
6	local typesetterPool = {}	1✔
7	local calculations = {}	1✔
8	local folioOrder = {}	1✔
9
10	local allTypesetters = function (callback)
11	local oldtypesetter = SILE.typesetter	8✔
12	for frame, typesetter in pairs(typesetterPool) do	24✔
13	SILE.typesetter = typesetter	16✔
14	callback(frame, typesetter)	16✔
15	end
16	SILE.typesetter = oldtypesetter	8✔
17	end
18
19	local nulTypesetter = pl.class(SILE.typesetters.base) -- we ignore this	1✔
20	nulTypesetter.outputLinesToPage = function () end	1✔
21
22	local parallelPagebreak = function ()
23	for i = 1, #folioOrder do	2✔
24	local thisPageFrames = folioOrder[i]	1✔
25	for j = 1, #thisPageFrames do	3✔
26	local frame = thisPageFrames[j]	2✔
27	local typesetter = typesetterPool[frame]	2✔
28	local thispage = {}	2✔
29	SU.debug("parallel", "Dumping lines for page on typesetter", typesetter.id)	2✔
30	if #typesetter.state.outputQueue > 0 and calculations[frame].mark == 0 then	2✔
31	-- More than one page worth of stuff here.
32	-- Just ship out one page and hope for the best.
33	SILE.typesetters.base.buildPage(typesetter)	×
34	else
35	for l = 1, calculations[frame].mark do	7✔
36	thispage[l] = table.remove(typesetter.state.outputQueue, 1)	10✔
37	SU.debug("parallel", thispage[l])	5✔
38	end
39	typesetter:outputLinesToPage(thispage)	2✔
40	end
41	end
42	SILE.documentState.documentClass:endPage()	1✔
43	for l = 1, #thisPageFrames do	3✔
44	local frame = thisPageFrames[l]	2✔
45	local typesetter = typesetterPool[frame]	2✔
46	typesetter:initFrame(typesetter.frame)	2✔
47	end
48	SILE.documentState.documentClass:newPage()	1✔
49	end
50	end
51
52	local addBalancingGlue = function (height)
53	allTypesetters(function (frame, typesetter)	4✔
54	local glue = height - calculations[frame].heightOfNewMaterial	4✔
55	if glue.length:tonumber() > 0 then	8✔
56	SU.debug("parallel", "Adding", glue, "to", frame)	1✔
57	typesetter:pushVglue({ height = glue })	1✔
58	end
59	calculations[frame].mark = #typesetter.state.outputQueue	4✔
60	end)
61	end
62
63	function package:_init (options)	1✔
64	base._init(self, options)	1✔
65	SILE.typesetter = nulTypesetter(SILE.getFrame("page"))	3✔
66	if type(options.frames) ~= "table" then	1✔
67	SU.error([[	×
68	Package parallel must be initialized with a set of appropriately named frames
69
70	This package is usually intended to be loaded from some supporting class or
71	from another package, responsible for correct initialization.
UNCOV 72	]])	×
73	end
74	for frame, typesetter in pairs(options.frames) do	3✔
75	typesetterPool[frame] = SILE.typesetters.base(SILE.getFrame(typesetter))	6✔
76	typesetterPool[frame].id = typesetter	2✔
77	typesetterPool[frame].buildPage = function ()	2✔
78	-- No thank you, I will do that.
79	end
80	-- Fixed leading here is obviously a bug, but n-way leading calculations
81	-- get very complicated...
82	-- typesetterPool[frame].leadingFor = function() return SILE.types.node.vglue(SILE.settings:get("document.lineskip")) end
83	local fontcommand = frame .. ":font"	2✔
84	self:registerCommand(frame, function (_, _) -- \left ...	4✔
85	SILE.typesetter = typesetterPool[frame]	2✔
86	SILE.call(fontcommand)	2✔
87	end)
88	if not SILE.Commands[fontcommand] then	2✔
89	self:registerCommand(fontcommand, function (_, _) end) -- to be overridden	4✔
90	end
91	end
92	if not options.folios then	1✔
93	folioOrder = { {} }	1✔
94	-- Note output order doesn't matter for PDF, but for our test suite it is
95	-- essential that the output order is deterministic, hence this sort()
96	for frame, _ in pl.tablex.sort(options.frames) do	7✔
97	table.insert(folioOrder[1], frame)	2✔
98	end
99	else
UNCOV 100	folioOrder = options.folios -- As usual we trust the user knows what they're doing	×
101	end
102	self.class.newPage = function (self_)	1✔
103	allTypesetters(function (frame, _)	2✔
104	calculations[frame] = { mark = 0 }	2✔
105	end)
106	self.class._base.newPage(self_)	1✔
107	SILE.call("sync")	1✔
108	end
109	allTypesetters(function (frame, _)	2✔
110	calculations[frame] = { mark = 0 }	2✔
111	end)
112	local oldfinish = self.class.finish	1✔
113	self.class.finish = function (self_)	1✔
114	parallelPagebreak()	1✔
115	oldfinish(self_)	1✔
116	end
117	end
118
119	function package:registerCommands ()	1✔
120	self:registerCommand("sync", function (_, _)	2✔
121	local anybreak = false	2✔
122	local maxheight = SILE.types.length()	2✔
123	SU.debug("parallel", "Trying a sync")	2✔
124	allTypesetters(function (_, typesetter)	4✔
125	SU.debug("parallel", "Leaving hmode on", typesetter.id)	4✔
126	typesetter:leaveHmode(true)	4✔
127	-- Now we have each typesetter's content boxed up onto the output stream
128	-- but page breaking has not been run. See if page breaking would cause a
129	-- break
130	local lines = pl.tablex.copy(typesetter.state.outputQueue)	4✔
131	if SILE.pagebuilder:findBestBreak({ vboxlist = lines, target = typesetter:getTargetLength() }) then	12✔
UNCOV 132	anybreak = true	×
133	end
134	end)
135
136	if anybreak then	2✔
UNCOV 137	parallelPagebreak()	×
UNCOV 138	return	×
139	end
140
141	allTypesetters(function (frame, typesetter)	4✔
142	calculations[frame].heightOfNewMaterial = SILE.types.length()	8✔
143	for i = calculations[frame].mark + 1, #typesetter.state.outputQueue do	8✔
144	local thisHeight = typesetter.state.outputQueue[i].height + typesetter.state.outputQueue[i].depth	4✔
145	calculations[frame].heightOfNewMaterial = calculations[frame].heightOfNewMaterial + thisHeight	8✔
146	end
147	if maxheight < calculations[frame].heightOfNewMaterial then	4✔
148	maxheight = calculations[frame].heightOfNewMaterial	2✔
149	end
150	SU.debug(	8✔
151	"parallel",	4✔
152	frame,	4✔
153	": pre-sync content=",	4✔
154	calculations[frame].mark,	4✔
155	", now",	4✔
156	#typesetter.state.outputQueue,	4✔
157	", height of material:",	4✔
158	calculations[frame].heightOfNewMaterial	4✔
159	)	4✔
160	end)
161	addBalancingGlue(maxheight)	2✔
162	end)
163	end
164
165	package.documentation = [[
166	\begin{document}
167	The \autodoc:package{parallel} package provides the mechanism for typesetting diglot or other parallel documents.
168	When used by a class such as \code{classes/diglot.lua}, it registers a command for each parallel frame, to allow you to select which frame you’re typesetting into.
169	It also defines the \autodoc:command{\sync} command, which adds vertical spacing to each frame such that the \em{next} set of text is vertically aligned.
170	See \url{https://sile-typesetter.org/examples/parallel.sil} and the source of \code{classes/diglot.lua} for examples which make the operation clear.
171	\end{document}
172	]]	1✔
173
174	return package	1✔

sile-typesetter / sile / 11135083927

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