6941442205

Committed 21 Nov 2023 08:56AM UTC coverage: 63.58% (+1.3%) from 62.266%

Build # 6941442205

Build Type

Pull #1904

github

Committed by

web-flow

Commit Message

Merge pull request #1891 from sile-typesetter/ot-tate

Pull Request Pull Request #1904: Merge develop into master (commit to next release being breaking)

Run Details

67 of 198 new or added lines in 20 files covered. (33.84%)

171 existing lines in 13 files now uncovered.

9907 of 15582 relevant lines covered (63.58%)

6710.82 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.measurement("1zw"),
    help = "Vertical offset between the ruby and the main text"
  })

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

sile-typesetter / sile / 6941442205

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