Module: Asciidoctor::Standoc::Inline

Included in:
Converter
Defined in:
lib/asciidoctor/standoc/inline.rb

Instance Method Summary collapse

Instance Method Details

#datauri(uri) ⇒ Object 



178
179
180
181
182
183
184
185
186
187
188
189
 
# File 'lib/asciidoctor/standoc/inline.rb', line 178

def datauri(uri)
  return uri if /^data:/.match(uri)
  types = MIME::Types.type_for(@localdir + uri)
  type = types ? types.first.to_s : 'text/plain; charset="utf-8"'
  # FIXME: nested uri path error(
  #   sources/plantuml/plantuml20200524-90467-1iqek5i.png ->
  #   sources/sources/plantuml/plantuml20200524-90467-1iqek5i.png)
  path = File.file?(uri) ? uri : @localdir + uri
  bin = File.open(path, 'rb', &:read)
  data = Base64.strict_encode64(bin)
  "data:#{type};base64,#{data}"
end

#image_attributes(node) ⇒ Object 



191
192
193
194
195
196
197
198
199
200
201
202
203
204
 
# File 'lib/asciidoctor/standoc/inline.rb', line 191

def image_attributes(node)
  uri = node.image_uri (node.attr("target") || node.target)
  types = /^data:/.match(uri) ? datauri2mime(uri) : MIME::Types.type_for(uri)
  type = types.first.to_s
  uri = uri.sub(%r{^data:image/\*;}, "data:#{type};")
  attr_code(src: uri, #@datauriimage ? datauri(uri) : uri,
            id: Metanorma::Utils::anchor_or_uuid,
            mimetype: type,
            height: node.attr("height") || "auto",
            width: node.attr("width") || "auto" ,
            filename: node.attr("filename"),
            title: node.attr("titleattr"),
            alt: node.alt == node.attr("default-alt") ? nil : node.alt)
end

#inline_anchor(node) ⇒ Object 



16
17
18
19
20
21
22
23
24
25
26
27
 
# File 'lib/asciidoctor/standoc/inline.rb', line 16

def inline_anchor(node)
  case node.type
  when :ref
    inline_anchor_ref node
  when :xref
    inline_anchor_xref node
  when :link
    inline_anchor_link node
  when :bibref
    inline_anchor_bibref node
  end
end

#inline_anchor_bibref(node) ⇒ Object 



69
70
71
72
73
74
75
76
77
78
79
 
# File 'lib/asciidoctor/standoc/inline.rb', line 69

def inline_anchor_bibref(node)
  eref_contents = (node.text || node.target || node.id)&.
    sub(/^\[?([^\[\]]+?)\]?$/, "[\\1]")
  eref_attributes = { id: node.target || node.id }
  @refids << (node.target || node.id)
  noko do |xml|
    xml.ref **attr_code(eref_attributes) do |r|
      r << eref_contents
    end
  end.join
end

#inline_anchor_link(node) ⇒ Object 



58
59
60
61
62
63
64
65
66
67
 
# File 'lib/asciidoctor/standoc/inline.rb', line 58

def inline_anchor_link(node)
  contents = node.text
  contents = "" if node.target.gsub(%r{^mailto:}, "") == node.text
  attributes = { "target": node.target, "alt": node.attr("title") }
  noko do |xml|
    xml.link **attr_code(attributes) do |l|
      l << contents
    end
  end.join
end

#inline_anchor_ref(node) ⇒ Object 



29
30
31
32
33
 
# File 'lib/asciidoctor/standoc/inline.rb', line 29

def inline_anchor_ref(node)
  noko do |xml|
    xml.bookmark nil, **attr_code(id: node.id)
  end.join
end

#inline_anchor_xref(node) ⇒ Object 



35
36
37
38
39
40
41
42
43
44
 
# File 'lib/asciidoctor/standoc/inline.rb', line 35

def inline_anchor_xref(node)
  noko do |xml|
    attrs = inline_anchor_xref_attrs(node)
    c = attrs[:text]
    attrs.delete(:text) unless c.nil?
    xml.xref **attr_code(attrs) do |x|
      x << c
    end
  end.join
end

#inline_anchor_xref_attrs(node) ⇒ Object 



46
47
48
49
50
51
52
53
54
55
56
 
# File 'lib/asciidoctor/standoc/inline.rb', line 46

def inline_anchor_xref_attrs(node)
  m = /^(?<drop>droploc%)?(?<case>capital%|lowercase%)?(?<drop2>droploc%)?
    (?<fn>fn(:\s*(?<text>.*))?)?$/x.match node.text
  casing = m.nil? ? nil : m[:case]&.sub(/%$/, "")
  droploc = m.nil? ? nil : ((m[:drop].nil? && m[:drop2].nil?) ? nil: true)
  f = (m.nil? || m[:fn].nil?) ? "inline" : "footnote"
  c = (!m.nil? && (%i[case fn drop drop2].any? { |x| !m[x].nil? })) ?
    m[:text] : node.text
  t = node.target.gsub(/^#/, "").gsub(%r{(\.xml|\.adoc)(#.*$)}, "\\2")
  { target: t, type: f, case: casing, droploc: droploc, text: c }
end

#inline_break(node) ⇒ Object 



97
98
99
100
101
102
 
# File 'lib/asciidoctor/standoc/inline.rb', line 97

def inline_break(node)
  noko do |xml|
    xml << node.text
    xml.br
  end.join
end

#inline_callout(node) ⇒ Object 



81
82
83
84
85
 
# File 'lib/asciidoctor/standoc/inline.rb', line 81

def inline_callout(node)
  noko do |xml|
    xml.callout node.text
  end.join
end

#inline_footnote(node) ⇒ Object 



87
88
89
90
91
92
93
94
95
 
# File 'lib/asciidoctor/standoc/inline.rb', line 87

def inline_footnote(node)
  @fn_number ||= 0
  noko do |xml|
    @fn_number += 1
    xml.fn **{ reference: @fn_number } do |fn|
      fn.p { |p| p << node.text }
    end
  end.join
end

#inline_image(node) ⇒ Object 



206
207
208
209
210
 
# File 'lib/asciidoctor/standoc/inline.rb', line 206

def inline_image(node)
  noko do |xml|
    xml.image **(image_attributes(node))
  end.join("")
end

#inline_indexterm(node) ⇒ Object 



212
213
214
215
216
217
218
219
220
221
222
 
# File 'lib/asciidoctor/standoc/inline.rb', line 212

def inline_indexterm(node)
  noko do |xml|
    node.type == :visible and xml << node.text
      terms = (node.attr("terms") || [node.text]).map { |x| xml_encode(x) }
    xml.index do |i|
      i.primary { |x| x << terms[0] }
      a = terms.dig(1) and i.secondary { |x| x << a }
      a = terms.dig(2) and i.tertiary { |x| x << a }
    end
  end.join
end

#inline_quoted(node) ⇒ Object 



148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
 
# File 'lib/asciidoctor/standoc/inline.rb', line 148

def inline_quoted(node)
  noko do |xml|
    case node.type
    when :emphasis then xml.em { |s| s << node.text }
    when :strong then xml.strong { |s| s << node.text }
    when :monospaced then xml.tt { |s| s << node.text }
    when :double then xml << "\"#{node.text}\""
    when :single then xml << "'#{node.text}'"
    when :superscript then xml.sup { |s| s << node.text }
    when :subscript then xml.sub { |s| s << node.text }
    when :asciimath then stem_parse(node.text, xml, :asciimath)
    when :latexmath then stem_parse(node.text, xml, :latexmath)
    else
      case node.role
        # the following three are legacy, they are now handled by macros
      when "alt" then xml.admitted { |a| a << node.text }
      when "deprecated" then xml.deprecates { |a| a << node.text }
      when "domain" then xml.domain { |a| a << node.text }

      when "strike" then xml.strike { |s| s << node.text }
      when "underline" then xml.underline { |s| s << node.text }
      when "smallcap" then xml.smallcap { |s| s << node.text }
      when "keyword" then xml.keyword { |s| s << node.text }
      else
        xml << node.text
      end
    end
  end.join
end

#latex_parse(text) ⇒ Object 



122
123
124
125
126
127
128
129
 
# File 'lib/asciidoctor/standoc/inline.rb', line 122

def latex_parse(text)
  lxm_input = Unicode2LaTeX.unicode2latex(HTMLEntities.new.decode(text))
  results = Latexmath.parse(lxm_input).to_mathml
  results.nil? and
    @log.add('Math', nil,
             "latexmlmath failed to process equation:\n#{lxm_input}")
  results&.sub(%r{<math ([^>]+ )?display="block"}, "<math \\1")
end

#page_break(node) ⇒ Object 



104
105
106
107
108
109
 
# File 'lib/asciidoctor/standoc/inline.rb', line 104

def page_break(node)
  attrs = {}
  node.option?("landscape") and attrs[:orientation] = "landscape"
  node.option?("portrait") and attrs[:orientation] = "portrait"
  noko { |xml| xml.pagebreak **attr_code(attrs)}.join
end

#refid?(x) ⇒ Boolean

Returns:

  • (Boolean) 


12
13
14
 
# File 'lib/asciidoctor/standoc/inline.rb', line 12

def refid?(x)
  @refids.include? x
end

#stem_parse(text, xml, style) ⇒ Object 



131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
 
# File 'lib/asciidoctor/standoc/inline.rb', line 131

def stem_parse(text, xml, style)
  if /&lt;([^:>&]+:)?math(\s+[^>&]+)?&gt; |
    <([^:>&]+:)?math(\s+[^>&]+)?>/x.match text
    math = xml_encode(text)
    xml.stem math, **{ type: "MathML" }
  elsif style == :latexmath
    latex = latex_parse(text) or return xml.stem **{ type: "MathML" }
    xml.stem **{ type: "MathML" } do |s|
      math = Nokogiri::XML.fragment(latex.sub(/<\?[^>]+>/, "")).elements[0]
      math.delete("alttext")
      s.parent.children = math
    end
  else
    xml.stem text&.gsub(/\&amp;#/, "&#"), **{ type: "AsciiMath" }
  end
end

#thematic_break(_node) ⇒ Object 



111
112
113
 
# File 'lib/asciidoctor/standoc/inline.rb', line 111

def thematic_break(_node)
  noko { |xml| xml.hr }.join
end

#xml_encode(text) ⇒ Object 



115
116
117
118
119
120
 
# File 'lib/asciidoctor/standoc/inline.rb', line 115

def xml_encode(text)
  HTMLEntities.new.encode(text, :basic, :hexadecimal).
    gsub(/&amp;gt;/, ">").gsub(/\&amp;lt;/, "<").gsub(/&amp;amp;/, "&").
    gsub(/&gt;/, ">").gsub(/&lt;/, "<").gsub(/&amp;/, "&").
    gsub(/&quot;/, '"').gsub(/&#xa;/, "\n").gsub(/&amp;#/, "&#")
end