Module: Asciidoctor::Standoc::Inline

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

Instance Method Summary collapse

Instance Method Details

#datauri(uri) ⇒ Object 



187
188
189
190
191
192
193
194
195
196
197
198
 
# File 'lib/asciidoctor/standoc/inline.rb', line 187

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 



200
201
202
203
204
205
206
207
208
209
210
211
212
213
 
# File 'lib/asciidoctor/standoc/inline.rb', line 200

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: 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 



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

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 



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

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 



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

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 



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

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

#inline_anchor_xref(node) ⇒ Object 



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

def inline_anchor_xref(node)
  m = /^(?<case>capital%|lowercase%)?(?<fn>fn(:\s*(?<text>.*))?)?$/.match node.text
  casing = m.nil? ? nil : m[:case]&.sub(/%$/, "")
  f = (m.nil? || m[:fn].nil?) ? "inline" : "footnote"
  c = (!m.nil? && (!m[:fn].nil? || !m[:case].nil?)) ? m[:text] : node.text
  t = node.target.gsub(/^#/, "").gsub(%r{(\.xml|\.adoc)(#.*$)}, "\\2")
  noko do |xml|
    xml.xref **attr_code(target: t, type: f, case: casing) do |x|
      x << c
    end
  end.join
end

#inline_break(node) ⇒ Object 



86
87
88
89
90
91
 
# File 'lib/asciidoctor/standoc/inline.rb', line 86

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

#inline_callout(node) ⇒ Object 



70
71
72
73
74
 
# File 'lib/asciidoctor/standoc/inline.rb', line 70

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

#inline_footnote(node) ⇒ Object 



76
77
78
79
80
81
82
83
84
 
# File 'lib/asciidoctor/standoc/inline.rb', line 76

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 



215
216
217
218
219
 
# File 'lib/asciidoctor/standoc/inline.rb', line 215

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

#inline_indexterm(node) ⇒ Object 



221
222
223
224
225
226
227
228
229
230
 
# File 'lib/asciidoctor/standoc/inline.rb', line 221

def inline_indexterm(node)
  noko do |xml|
    node.type == :visible and xml << node.text
    terms = node.attr("terms") ||
      [Nokogiri::XML("<a>#{node.text}</a>").xpath("//text()").text]
    xml.index nil, **attr_code(primary: terms[0],
                               secondary: terms.dig(1),
                               tertiary: terms.dig(2))
  end.join
end

#inline_quoted(node) ⇒ Object 



158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
 
# File 'lib/asciidoctor/standoc/inline.rb', line 158

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 "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 



132
133
134
135
136
137
138
139
 
# File 'lib/asciidoctor/standoc/inline.rb', line 132

def latex_parse(text)
  lxm_input = Unicode2LaTeX.unicode2latex(HTMLEntities.new.decode(text))
  results = latex_run(lxm_input)
  results.nil? and
    @log.add('Math', nil,
             "latexmlmath failed to process equation:\n#{lxm_input}")
  results
end

#latex_run(lxm_input) ⇒ Object 



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

def latex_run(lxm_input)
  results = nil
  Metanorma::Standoc::Requirements[:latexml].cmd.each_with_index do |cmd, i|
    warn "Retrying with #{cmd}" if i > 0
    results = latex_run1(lxm_input, cmd)
    if $CHILD_STATUS.to_i.zero?
      warn "Success!" if i > 0
      break
    end
  end
  $CHILD_STATUS.to_i.zero? ? results : nil
end

#latex_run1(lxm_input, cmd) ⇒ Object 



111
112
113
114
115
116
117
 
# File 'lib/asciidoctor/standoc/inline.rb', line 111

def latex_run1(lxm_input, cmd)
  IO.popen(cmd, "r+", external_encoding: "UTF-8") do |io|
    io.write(lxm_input)
    io.close_write
    io.read
  end
end

#page_break(node) ⇒ Object 



93
94
95
96
97
98
 
# File 'lib/asciidoctor/standoc/inline.rb', line 93

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) 


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

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

#stem_parse(text, xml, style) ⇒ Object 



141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
 
# File 'lib/asciidoctor/standoc/inline.rb', line 141

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, **{ type: "AsciiMath" }
  end
end

#thematic_break(_node) ⇒ Object 



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

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

#xml_encode(text) ⇒ Object 



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

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")
end