9409557472

Committed 07 Jun 2024 12:09AM UTC coverage: 69.448% (-4.5%) from 73.988%

Build # 9409557472

Build Type

push

github

Committed by

alerque

Commit Message

fix(build): Distribute vendored compat-5.3.c source file

Run Details

12025 of 17315 relevant lines covered (69.45%)

6023.46 hits per line

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

0.0

/packages/ruby/init.lua

local base = require("packages.base")

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

local isLatin = function (char)
   return (char > 0x20 and char <= 0x24F)
      or (char >= 0x300 and char <= 0x36F)
      or (char >= 0x1DC0 and char <= 0x1EFF)
      or (char >= 0x2C60 and char <= 0x2c7F)
end

local checkIfSpacerNeeded = function (reading)
   -- First, did we have a ruby node at all?
   if not SILE.scratch.lastRubyBox then
      return
   end
   -- Does the current reading start with a latin?
   if not isLatin(SU.codepoint(SU.firstChar(reading))) then
      return
   end
   -- Did we have some nodes recently?
   local top = #SILE.typesetter.state.nodes
   if top < 2 then
      return
   end
   -- Have we had other stuff since the last ruby node?
   if
      SILE.typesetter.state.nodes[top] ~= SILE.scratch.lastRubyBox
      and SILE.typesetter.state.nodes[top - 1] ~= SILE.scratch.lastRubyBox
   then
      return
   end
   -- Does the previous reading end with a latin?
   if not isLatin(SU.codepoint(SU.lastChar(SILE.scratch.lastRubyText))) then
      return
   end
   -- OK, we need a spacer!
   SILE.typesetter:pushGlue(SILE.settings:get("ruby.latinspacer"))
end

function package:_init ()
   base._init(self)
   -- Japanese language support defines units which are useful here
   self:loadPackage("font-fallback")
   SILE.call("font:add-fallback", { family = "Noto Sans CJK JP" })
   SILE.languageSupport.loadLanguage("ja")
end

function package.declareSettings (_)
   SILE.settings:declare({
      parameter = "ruby.height",
      type = "measurement",
      default = SILE.types.measurement("1zw"),
      help = "Vertical offset between the ruby and the main text",
   })

   SILE.settings:declare({
      parameter = "ruby.latinspacer",
      type = "glue",
      default = SILE.types.node.glue("0.25em"),
      help = "Glue added between consecutive Latin ruby",
   })

   SILE.settings:declare({
      parameter = "ruby.opentype",
      type = "boolean",
      default = true,
      help = "Use OpenType tate feature instead of of a bold weight",
   })
end

function package:registerCommands ()
   self:registerCommand("ruby:font", function (_, _)
      if SILE.settings:get("ruby.opentype") then
         SILE.call("font", { size = "0.6zw", features = "+ruby" })
      else
         SILE.call("font", { size = "0.6zw", weight = 700 })
      end
   end)

   self:registerCommand("ruby", function (options, content)
      local reading = SU.required(options, "reading", "\\ruby")
      SILE.typesetter:setpar("")

      checkIfSpacerNeeded(reading)

      local rubybox = SILE.call("hbox", {}, function ()
         SILE.settings:temporarily(function ()
            SILE.call("noindent")
            SILE.call("ruby:font")
            SILE.typesetter:typeset(reading)
         end)
      end)
      rubybox.outputYourself = function (box, typesetter, line)
         local ox = typesetter.frame.state.cursorX
         local oy = typesetter.frame.state.cursorY
         typesetter.frame:advanceWritingDirection(rubybox.width)
         typesetter.frame:advancePageDirection(-SILE.settings:get("ruby.height"))
         SILE.outputter:setCursor(typesetter.frame.state.cursorX, typesetter.frame.state.cursorY)
         for i = 1, #box.value do
            local node = box.value[i]
            node:outputYourself(typesetter, line)
         end
         typesetter.frame.state.cursorX = ox
         typesetter.frame.state.cursorY = oy
      end
      -- measure the content
      local cbox = SILE.call("hbox", {}, content)
      SU.debug("ruby", "base box is", cbox)
      SU.debug("ruby", "reading is", rubybox)
      if cbox:lineContribution() > rubybox:lineContribution() then
         SU.debug("ruby", "Base is longer, offsetting ruby to fit")
         -- This is actually the offset against the base
         rubybox.width = SILE.types.length(cbox:lineContribution() - rubybox:lineContribution()) / 2
      else
         local diff = rubybox:lineContribution() - cbox:lineContribution()
         local to_insert = SILE.types.length(diff / 2)
         SU.debug("ruby", "Ruby is longer, inserting", to_insert, "either side of base")
         cbox.width = rubybox:lineContribution()
         rubybox.height = 0
         rubybox.width = 0
         -- add spaces at beginning and end
         table.insert(cbox.value, 1, SILE.types.node.glue(to_insert))
         table.insert(cbox.value, SILE.types.node.glue(to_insert))
      end
      SILE.scratch.lastRubyBox = rubybox
      SILE.scratch.lastRubyText = reading
   end)
end

package.documentation = [[
\begin{document}
\font:add-fallback[family=Noto Sans CJK JP]
\use[module=packages.ruby]
Japanese texts often contain pronunciation hints (called \em{furigana}) for difficult kanji or foreign words.
These hints are traditionally placed either above (in horizontal typesetting) or beside (in vertical typesetting) the word that they explain.
The typesetting term for these glosses is \em{ruby}.

The \autodoc:package{ruby} package provides the \autodoc:command[check=false]{\ruby[reading=<ruby text>]{<base text>}} command which sets a piece of ruby above or beside the base text.
For example:

\set[parameter=ruby.height,value=12pt]
\define[command=ja]{\font[family=Noto Sans CJK JP,language=ja]{\process}}

\begin{autodoc:codeblock}
\\ruby[reading=\ja{れいわ}]\{\ja{令和}\}
\end{autodoc:codeblock}

Produces:
\medskip
\ja{\ruby[reading=れいわ]{令和}}

\font:remove-fallback
\end{document}
]]

return package

1	local base = require("packages.base")	×
2
3	local package = pl.class(base)	×
4	package._name = "ruby"	×
5
6	local isLatin = function (char)
7	return (char > 0x20 and char <= 0x24F)	×
8	or (char >= 0x300 and char <= 0x36F)	×
9	or (char >= 0x1DC0 and char <= 0x1EFF)	×
10	or (char >= 0x2C60 and char <= 0x2c7F)	×
11	end
12
13	local checkIfSpacerNeeded = function (reading)
14	-- First, did we have a ruby node at all?
15	if not SILE.scratch.lastRubyBox then	×
16	return	×
17	end
18	-- Does the current reading start with a latin?
19	if not isLatin(SU.codepoint(SU.firstChar(reading))) then	×
20	return	×
21	end
22	-- Did we have some nodes recently?
23	local top = #SILE.typesetter.state.nodes	×
24	if top < 2 then	×
25	return	×
26	end
27	-- Have we had other stuff since the last ruby node?
28	if
29	SILE.typesetter.state.nodes[top] ~= SILE.scratch.lastRubyBox	×
30	and SILE.typesetter.state.nodes[top - 1] ~= SILE.scratch.lastRubyBox	×
31	then
32	return	×
33	end
34	-- Does the previous reading end with a latin?
35	if not isLatin(SU.codepoint(SU.lastChar(SILE.scratch.lastRubyText))) then	×
36	return	×
37	end
38	-- OK, we need a spacer!
39	SILE.typesetter:pushGlue(SILE.settings:get("ruby.latinspacer"))	×
40	end
41
42	function package:_init ()	×
43	base._init(self)	×
44	-- Japanese language support defines units which are useful here
45	self:loadPackage("font-fallback")	×
46	SILE.call("font:add-fallback", { family = "Noto Sans CJK JP" })	×
47	SILE.languageSupport.loadLanguage("ja")	×
48	end
49
50	function package.declareSettings (_)	×
51	SILE.settings:declare({	×
52	parameter = "ruby.height",
53	type = "measurement",
54	default = SILE.types.measurement("1zw"),
55	help = "Vertical offset between the ruby and the main text",
56	})
57
58	SILE.settings:declare({	×
59	parameter = "ruby.latinspacer",
60	type = "glue",
61	default = SILE.types.node.glue("0.25em"),
62	help = "Glue added between consecutive Latin ruby",
63	})
64
65	SILE.settings:declare({	×
66	parameter = "ruby.opentype",
67	type = "boolean",
68	default = true,
69	help = "Use OpenType tate feature instead of of a bold weight",
70	})
71	end
72
73	function package:registerCommands ()	×
74	self:registerCommand("ruby:font", function (_, _)	×
75	if SILE.settings:get("ruby.opentype") then	×
76	SILE.call("font", { size = "0.6zw", features = "+ruby" })	×
77	else
78	SILE.call("font", { size = "0.6zw", weight = 700 })	×
79	end
80	end)
81
82	self:registerCommand("ruby", function (options, content)	×
83	local reading = SU.required(options, "reading", "\\ruby")	×
84	SILE.typesetter:setpar("")	×
85
86	checkIfSpacerNeeded(reading)	×
87
88	local rubybox = SILE.call("hbox", {}, function ()	×
89	SILE.settings:temporarily(function ()	×
90	SILE.call("noindent")	×
91	SILE.call("ruby:font")	×
92	SILE.typesetter:typeset(reading)	×
93	end)
94	end)
95	rubybox.outputYourself = function (box, typesetter, line)
96	local ox = typesetter.frame.state.cursorX	×
97	local oy = typesetter.frame.state.cursorY	×
98	typesetter.frame:advanceWritingDirection(rubybox.width)	×
99	typesetter.frame:advancePageDirection(-SILE.settings:get("ruby.height"))	×
100	SILE.outputter:setCursor(typesetter.frame.state.cursorX, typesetter.frame.state.cursorY)	×
101	for i = 1, #box.value do	×
102	local node = box.value[i]	×
103	node:outputYourself(typesetter, line)	×
104	end
105	typesetter.frame.state.cursorX = ox	×
106	typesetter.frame.state.cursorY = oy	×
107	end
108	-- measure the content
109	local cbox = SILE.call("hbox", {}, content)	×
110	SU.debug("ruby", "base box is", cbox)	×
111	SU.debug("ruby", "reading is", rubybox)	×
112	if cbox:lineContribution() > rubybox:lineContribution() then	×
113	SU.debug("ruby", "Base is longer, offsetting ruby to fit")	×
114	-- This is actually the offset against the base
115	rubybox.width = SILE.types.length(cbox:lineContribution() - rubybox:lineContribution()) / 2	×
116	else
117	local diff = rubybox:lineContribution() - cbox:lineContribution()	×
118	local to_insert = SILE.types.length(diff / 2)	×
119	SU.debug("ruby", "Ruby is longer, inserting", to_insert, "either side of base")	×
120	cbox.width = rubybox:lineContribution()	×
121	rubybox.height = 0	×
122	rubybox.width = 0	×
123	-- add spaces at beginning and end
124	table.insert(cbox.value, 1, SILE.types.node.glue(to_insert))	×
125	table.insert(cbox.value, SILE.types.node.glue(to_insert))	×
126	end
127	SILE.scratch.lastRubyBox = rubybox	×
128	SILE.scratch.lastRubyText = reading	×
129	end)
130	end
131
132	package.documentation = [[
133	\begin{document}
134	\font:add-fallback[family=Noto Sans CJK JP]
135	\use[module=packages.ruby]
136	Japanese texts often contain pronunciation hints (called \em{furigana}) for difficult kanji or foreign words.
137	These hints are traditionally placed either above (in horizontal typesetting) or beside (in vertical typesetting) the word that they explain.
138	The typesetting term for these glosses is \em{ruby}.
139
140	The \autodoc:package{ruby} package provides the \autodoc:command[check=false]{\ruby[reading=<ruby text>]{<base text>}} command which sets a piece of ruby above or beside the base text.
141	For example:
142
143	\set[parameter=ruby.height,value=12pt]
144	\define[command=ja]{\font[family=Noto Sans CJK JP,language=ja]{\process}}
145
146	\begin{autodoc:codeblock}
147	\\ruby[reading=\ja{れいわ}]\{\ja{令和}\}
148	\end{autodoc:codeblock}
149
150	Produces:
151	\medskip
152	\ja{\ruby[reading=れいわ]{令和}}
153
154	\font:remove-fallback
155	\end{document}
156	]]	×
157
158	return package	×

sile-typesetter / sile / 9409557472

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