Class: Metanorma::Compile
- Inherits:
-
Object
- Object
- Metanorma::Compile
- Defined in:
- lib/metanorma/compile.rb,
lib/metanorma/extract.rb,
lib/metanorma/sectionsplit.rb,
lib/metanorma/compile_options.rb,
lib/metanorma/compile_validate.rb
Constant Summary collapse
- REQUIREMENT_XPATH =
"//requirement | //xmlns:requirement | //recommendation | "\ "//xmlns:recommendation | //permission | //xmlns:permission".freeze
- SPLITSECTIONS =
[["//preface/*", "preface"], ["//sections/*", "sections"], ["//annex", nil], ["//bibliography/*[not(@hidden = 'true')]", "bibliography"], ["//indexsect", nil]].freeze
Instance Attribute Summary collapse
- #errors ⇒ Array<String> readonly
- #processor ⇒ Array<String> readonly
Instance Method Summary collapse
- #build_collection(xml, presxml, filename, dir, opts = {}) ⇒ Object
- #clean_sourcecode(xml) ⇒ Object
- #coll_cover ⇒ Object
- #collection_manifest(filename, files, origxml, _presxml, dir) ⇒ Object
- #collection_setup(filename, dir) ⇒ Object
- #collectionyaml(files, xml) ⇒ Object
- #compile(filename, options = {}) ⇒ Object
- #copy_repo_items_biblio(ins, section, xml) ⇒ Object
- #create_sectionfile(xml, out, file, chunk, parentnode) ⇒ Object
- #emptydoc(xml) ⇒ Object
- #eref_to_internal_eref(section, xml, key) ⇒ Object
- #eref_to_internal_eref1(elem, key, url) ⇒ Object
- #eref_to_internal_eref_select(section, xml) ⇒ Object
- #export_output(fname, content, **options) ⇒ Object
- #extract(isodoc, dirname, extract_types) ⇒ Object
- #font_install(opt) ⇒ Object
- #get_extensions(options) ⇒ Object
- #image_export(xml, dirname) ⇒ Object
-
#initialize ⇒ Compile
constructor
A new instance of Compile.
- #insert_indirect_biblio(ins, refs, prefix) ⇒ Object
- #make_anchor(anchor) ⇒ Object
-
#new_hidden_ref(xmldoc) ⇒ Object
from standoc.
- #ns(xpath) ⇒ Object
- #options_extract(filename, options) ⇒ Object
- #process_ext(ext, file, isodoc, fnames, options) ⇒ Object
- #process_ext_simple(ext, isodoc, fnames, options, isodoc_options) ⇒ Object
-
#process_exts(filename, extensions, file, isodoc, options) ⇒ Object
isodoc is Raw Metanorma XML.
- #process_exts1(ext, fnames, isodoc, options, isodoc_options) ⇒ Object
- #process_input(filename, options) ⇒ Object
- #process_input_adoc(filename, options) ⇒ Object
- #process_input_xml(filename, _options) ⇒ Object
- #process_output_threaded(ext, fnames1, options1, isodoc_options1) ⇒ Object
- #process_output_unthreaded(ext, fnames, isodoc, isodoc_options) ⇒ Object
- #read_file(filename) ⇒ Object
- #recursive_string_keys(hash) ⇒ Object
- #relaton_export(isodoc, options) ⇒ Object
- #require_libraries(options) ⇒ Object
- #requirement_export(xml, dirname) ⇒ Object
- #sectionfile(fulldoc, xml, file, chunk, parentnode) ⇒ Object
- #sectionsplit(xml, filename, dir) ⇒ Object
-
#sectionsplit_convert(input_filename, file, output_filename = nil, opts = {}) ⇒ Object
assume we pass in Presentation XML, but we want to recover Semantic XML.
- #sourcecode_export(xml, dirname) ⇒ Object
- #svg_preprocess(xml) ⇒ Object
- #svgmap_wrap(svg) ⇒ Object
- #titlerender(section) ⇒ Object
- #validate_format(options) ⇒ Object
- #validate_options(options) ⇒ Object
- #validate_type(options) ⇒ Object
- #wrap_html(options, file_extension, outfilename) ⇒ Object
- #xml_options_extract(file) ⇒ Object
- #xref_preprocess(xml) ⇒ Object
- #xref_process(section, xml, key) ⇒ Object
- #xref_to_internal_eref(xml, key) ⇒ Object
Constructor Details
Instance Attribute Details
#errors ⇒ Array<String> (readonly)
18 19 20 |
# File 'lib/metanorma/compile.rb', line 18 def errors @errors end |
#processor ⇒ Array<String> (readonly)
18 19 20 |
# File 'lib/metanorma/compile.rb', line 18 def processor @processor end |
Instance Method Details
#build_collection(xml, presxml, filename, dir, opts = {}) ⇒ Object
22 23 24 25 26 27 28 29 30 |
# File 'lib/metanorma/sectionsplit.rb', line 22 def build_collection(xml, presxml, filename, dir, opts = {}) base = File.basename(filename) collection_setup(base, dir) files = sectionsplit(xml, base, dir) collection_manifest(base, files, xml, presxml, dir).render( { format: %i(html), output_folder: "#{filename}_collection", coverpage: File.join(dir, "cover.html") }.merge(opts), ) end |
#clean_sourcecode(xml) ⇒ Object
13 14 15 16 17 18 |
# File 'lib/metanorma/extract.rb', line 13 def clean_sourcecode(xml) xml.xpath(".//callout | .//annotation | .//xmlns:callout | "\ ".//xmlns:annotation").each(&:remove) xml.xpath(".//br | .//xmlns:br").each { |x| x.replace("\n") } HTMLEntities.new.decode(xml.children.to_xml) end |
#coll_cover ⇒ Object
47 48 49 50 51 52 53 54 55 56 57 |
# File 'lib/metanorma/sectionsplit.rb', line 47 def coll_cover <<~COVER <html><head/> <body> <h1>{{ doctitle }}</h1> <h2>{{ docnumber }}</h2> <nav>{{ labels["navigation"] }}</nav> </body> </html> COVER end |
#collection_manifest(filename, files, origxml, _presxml, dir) ⇒ Object
32 33 34 35 36 37 |
# File 'lib/metanorma/sectionsplit.rb', line 32 def collection_manifest(filename, files, origxml, _presxml, dir) File.open(File.join(dir, "#{filename}.html.yaml"), "w:UTF-8") do |f| f.write(collectionyaml(files, origxml)) end Metanorma::Collection.parse File.join(dir, "#{filename}.html.yaml") end |
#collection_setup(filename, dir) ⇒ Object
39 40 41 42 43 44 45 |
# File 'lib/metanorma/sectionsplit.rb', line 39 def collection_setup(filename, dir) FileUtils.mkdir_p "#{filename}_collection" if filename FileUtils.mkdir_p dir File.open(File.join(dir, "cover.html"), "w:UTF-8") do |f| f.write(coll_cover) end end |
#collectionyaml(files, xml) ⇒ Object
230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 |
# File 'lib/metanorma/sectionsplit.rb', line 230 def collectionyaml(files, xml) ret = { directives: ["presentation-xml", "bare-after-first"], bibdata: { title: { type: "title-main", language: @lang, content: xml.at(ns("//bibdata/title")).text }, type: "collection", docid: { type: xml.at(ns("//bibdata/docidentifier/@type")).text, id: xml.at(ns("//bibdata/docidentifier")).text, }, }, manifest: { level: "collection", title: "Collection", docref: files.sort_by { |f| f[:order] }.each.map do |f| { fileref: f[:url], identifier: f[:title] } end }, } recursive_string_keys(ret).to_yaml end |
#compile(filename, options = {}) ⇒ Object
27 28 29 30 31 32 33 34 35 36 37 38 |
# File 'lib/metanorma/compile.rb', line 27 def compile(filename, = {}) require_libraries() = (filename, ) () @processor = @registry.find_processor([:type].to_sym) extensions = get_extensions() or return nil (file, isodoc = process_input(filename, )) or return nil relaton_export(isodoc, ) extract(isodoc, [:extract], [:extract_type]) font_install() process_exts(filename, extensions, file, isodoc, ) end |
#copy_repo_items_biblio(ins, section, xml) ⇒ Object
194 195 196 197 198 199 200 201 |
# File 'lib/metanorma/sectionsplit.rb', line 194 def copy_repo_items_biblio(ins, section, xml) xml.xpath(ns("//references/bibitem[docidentifier/@type = 'repository']")) .each_with_object([]) do |b, m| section.at("//*[@bibitemid = '#{b['id']}']") or next ins << b.dup m << b["id"] end end |
#create_sectionfile(xml, out, file, chunk, parentnode) ⇒ Object
91 92 93 94 95 96 97 98 99 100 101 102 |
# File 'lib/metanorma/sectionsplit.rb', line 91 def create_sectionfile(xml, out, file, chunk, parentnode) ins = out.at(ns("//misccontainer")) || out.at(ns("//bibdata")) if parentnode ins.next = "<#{parentnode}/>" ins.next.add_child(chunk.dup) else ins.next = chunk.dup end xref_process(out, xml, @key) outname = "#{file}.xml" File.open(File.join(@splitdir, outname), "w:UTF-8") { |f| f.write(out) } outname end |
#emptydoc(xml) ⇒ Object
76 77 78 79 80 81 82 83 |
# File 'lib/metanorma/sectionsplit.rb', line 76 def emptydoc(xml) out = xml.dup out.xpath( ns("//preface | //sections | //annex | //bibliography/clause | "\ "//bibliography/references[not(@hidden = 'true')] | //indexsect"), ).each(&:remove) out end |
#eref_to_internal_eref(section, xml, key) ⇒ Object
155 156 157 158 159 160 161 162 163 |
# File 'lib/metanorma/sectionsplit.rb', line 155 def eref_to_internal_eref(section, xml, key) eref_to_internal_eref_select(section, xml).each_with_object([]) do |x, m| url = xml.at(ns("//bibitem[@id = '#{x}']/uri[@type = 'citation']")) section.xpath(("//*[@bibitemid = '#{x}']")).each do |e| id = eref_to_internal_eref1(e, key, url) id and m << id end end end |
#eref_to_internal_eref1(elem, key, url) ⇒ Object
165 166 167 168 169 170 171 172 173 174 175 176 |
# File 'lib/metanorma/sectionsplit.rb', line 165 def eref_to_internal_eref1(elem, key, url) if url elem.name = "link" elem["target"] = url nil else elem["bibitemid"] = "#{key}_#{elem['bibitemid']}" elem << make_anchor(elem["bibitemid"]) elem["type"] = key elem["bibitemid"] end end |
#eref_to_internal_eref_select(section, xml) ⇒ Object
178 179 180 181 182 183 184 185 |
# File 'lib/metanorma/sectionsplit.rb', line 178 def eref_to_internal_eref_select(section, xml) refs = section.xpath(("//*/@bibitemid")).map { |x| x.text } # rubocop:disable Style/SymbolProc refs.uniq.reject do |x| xml.at(ns("//bibitem[@id = '#{x}'][@type = 'internal']")) || xml.at(ns("//bibitem[@id = '#{x}']"\ "[docidentifier/@type = 'repository']")) end end |
#export_output(fname, content, **options) ⇒ Object
83 84 85 86 |
# File 'lib/metanorma/compile.rb', line 83 def export_output(fname, content, **) mode = [:binary] ? "wb" : "w:UTF-8" File.open(fname, mode) { |f| f.write content } end |
#extract(isodoc, dirname, extract_types) ⇒ Object
20 21 22 23 24 25 26 27 28 29 30 31 32 |
# File 'lib/metanorma/extract.rb', line 20 def extract(isodoc, dirname, extract_types) return unless dirname extract_types.nil? || extract_types.empty? and extract_types = %i[sourcecode image requirement] FileUtils.rm_rf dirname FileUtils.mkdir_p dirname xml = Nokogiri::XML(isodoc) { |config| config.huge } sourcecode_export(xml, dirname) if extract_types.include? :sourcecode image_export(xml, dirname) if extract_types.include? :image extract_types.include?(:requirement) and requirement_export(xml, dirname) end |
#font_install(opt) ⇒ Object
56 57 58 59 60 61 62 63 64 65 66 |
# File 'lib/metanorma/compile_options.rb', line 56 def font_install(opt) FontistUtils.install_fonts(@processor, opt) unless @fontist_installed @fontist_installed = true return if !opt[:fonts] || opt[:fontlicenseagreement] == "continue-without-fonts" confirm = opt[:fontlicenseagreement] == "no-install-fonts" ? "no" : "yes" CSV.parse_line(opt[:fonts], col_sep: ";").map(&:strip).each do |f| Fontist::Font.install(f, confirmation: confirm) end end |
#get_extensions(options) ⇒ Object
36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 |
# File 'lib/metanorma/compile_options.rb', line 36 def get_extensions() [:extension_keys] ||= @processor.output_formats.reduce([]) { |memo, (k, _)| memo << k } extensions = [:extension_keys].reduce([]) do |memo, e| if @processor.output_formats[e] then memo << e else = "[metanorma] Error: #{e} format is not supported for this standard." @errors << Util.log(, :error) memo end end if !extensions.include?(:presentation) && extensions.any? do |e| @processor.use_presentation_xml(e) end extensions << :presentation end extensions end |
#image_export(xml, dirname) ⇒ Object
44 45 46 47 48 49 50 51 52 53 54 55 56 |
# File 'lib/metanorma/extract.rb', line 44 def image_export(xml, dirname) xml.at("//image | //xmlns:image") or return FileUtils.mkdir_p "#{dirname}/image" xml.xpath("//image | //xmlns:image").each_with_index do |s, i| next unless /^data:image/.match? s["src"] %r{^data:image/(?<imgtype>[^;]+);base64,(?<imgdata>.+)$} =~ s["src"] fn = s["filename"] || sprintf("image-%<num>04d.%<name>s", num: i, name: imgtype) export_output("#{dirname}/image/#{fn}", Base64.strict_decode64(imgdata), binary: true) end end |
#insert_indirect_biblio(ins, refs, prefix) ⇒ Object
203 204 205 206 207 208 209 210 211 |
# File 'lib/metanorma/sectionsplit.rb', line 203 def insert_indirect_biblio(ins, refs, prefix) refs.each do |x| ins << <<~BIBENTRY <bibitem id="#{x}" type="internal"> <docidentifier type="repository">#{x.sub(/^#{prefix}_/, "#{prefix}/")}</docidentifier> </bibitem> BIBENTRY end end |
#make_anchor(anchor) ⇒ Object
139 140 141 142 |
# File 'lib/metanorma/sectionsplit.rb', line 139 def make_anchor(anchor) "<localityStack><locality type='anchor'><referenceFrom>"\ "#{anchor}</referenceFrom></locality></localityStack>" end |
#new_hidden_ref(xmldoc) ⇒ Object
from standoc
188 189 190 191 192 |
# File 'lib/metanorma/sectionsplit.rb', line 188 def new_hidden_ref(xmldoc) ins = xmldoc.at("bibliography") or xmldoc.root << "<bibliography/>" and ins = xmldoc.at("bibliography") ins.add_child("<references hidden='true' normative='false'/>").first end |
#ns(xpath) ⇒ Object
18 19 20 |
# File 'lib/metanorma/sectionsplit.rb', line 18 def ns(xpath) @isodoc.ns(xpath) end |
#options_extract(filename, options) ⇒ Object
19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 |
# File 'lib/metanorma/compile_options.rb', line 19 def (filename, ) content = read_file(filename) o = Metanorma::Input::Asciidoc.new.(content) .merge((content)) [:type] ||= o[:type]&.to_sym t = @registry.alias([:type]) and [:type] = t dir = filename.sub(%r(/[^/]+$), "/") [:relaton] ||= File.join(dir, o[:relaton]) if o[:relaton] [:sourcecode] ||= File.join(dir, o[:sourcecode]) if o[:sourcecode] [:extension_keys] ||= o[:extensions]&.split(/, */)&.map(&:to_sym) [:extension_keys] = nil if [:extension_keys] == [:all] [:format] ||= :asciidoc [:filename] = filename [:fontlicenseagreement] ||= "no-install-fonts" end |
#process_ext(ext, file, isodoc, fnames, options) ⇒ Object
111 112 113 114 115 116 117 118 119 120 121 |
# File 'lib/metanorma/compile.rb', line 111 def process_ext(ext, file, isodoc, fnames, ) fnames[:ext] = @processor.output_formats[ext] fnames[:out] = fnames[:f].sub(/\.[^.]+$/, ".#{fnames[:ext]}") = (file, , ext) thread = nil unless process_ext_simple(ext, isodoc, fnames, , ) thread = process_exts1(ext, fnames, isodoc, , ) end thread end |
#process_ext_simple(ext, isodoc, fnames, options, isodoc_options) ⇒ Object
123 124 125 126 127 128 129 130 131 132 133 134 135 |
# File 'lib/metanorma/compile.rb', line 123 def process_ext_simple(ext, isodoc, fnames, , ) if ext == :rxl relaton_export(isodoc, .merge(relaton: fnames[:out])) elsif [:passthrough_presentation_xml] && ext == :presentation f = File.exist?(fnames[:f]) ? fnames[:f] : fnames[:orig_filename] FileUtils.cp f, fnames[:presentationxml] elsif ext == :html && [:sectionsplit] sectionsplit_convert(fnames[:xml], isodoc, fnames[:out], ) else return false end true end |
#process_exts(filename, extensions, file, isodoc, options) ⇒ Object
isodoc is Raw Metanorma XML
98 99 100 101 102 103 104 105 106 107 108 109 |
# File 'lib/metanorma/compile.rb', line 98 def process_exts(filename, extensions, file, isodoc, ) f = File.(change_output_dir()) fnames = { xml: f.sub(/\.[^.]+$/, ".xml"), f: f, orig_filename: File.(filename), presentationxml: f.sub(/\.[^.]+$/, ".presentation.xml") } @queue = ::Metanorma::WorkersPool .new(ENV["METANORMA_PARALLEL"]&.to_i || 3) Util.sort_extensions_execution(extensions).each do |ext| process_ext(ext, file, isodoc, fnames, ) end @queue.shutdown end |
#process_exts1(ext, fnames, isodoc, options, isodoc_options) ⇒ Object
137 138 139 140 141 142 143 144 145 146 |
# File 'lib/metanorma/compile.rb', line 137 def process_exts1(ext, fnames, isodoc, , ) if @processor.use_presentation_xml(ext) @queue.schedule(ext, fnames.dup, .dup, .dup) do |a, b, c, d| process_output_threaded(a, b, c, d) end else process_output_unthreaded(ext, fnames, isodoc, ) end end |
#process_input(filename, options) ⇒ Object
40 41 42 43 44 45 46 47 48 49 |
# File 'lib/metanorma/compile.rb', line 40 def process_input(filename, ) case extname = File.extname(filename) when ".adoc" then process_input_adoc(filename, ) when ".xml" then process_input_xml(filename, ) else Util.log("[metanorma] Error: file extension #{extname} "\ "is not supported.", :error) nil end end |
#process_input_adoc(filename, options) ⇒ Object
51 52 53 54 55 56 57 58 59 60 |
# File 'lib/metanorma/compile.rb', line 51 def process_input_adoc(filename, ) Util.log("[metanorma] Processing: AsciiDoc input.", :info) file = read_file(filename) [:asciimath] and file.sub!(/^(=[^\n]+\n)/, "\\1:mn-keep-asciimath:\n") dir = File.dirname(filename) dir != "." and file.gsub!(/^include::/, "include::#{dir}/") [file, @processor.input_to_isodoc(file, filename, )] end |
#process_input_xml(filename, _options) ⇒ Object
62 63 64 65 66 67 |
# File 'lib/metanorma/compile.rb', line 62 def process_input_xml(filename, ) Util.log("[metanorma] Processing: Metanorma XML input.", :info) # TODO NN: this is a hack -- we should provide/bridge the # document attributes in Metanorma XML ["", read_file(filename)] end |
#process_output_threaded(ext, fnames1, options1, isodoc_options1) ⇒ Object
148 149 150 151 152 153 154 |
# File 'lib/metanorma/compile.rb', line 148 def process_output_threaded(ext, fnames1, , ) @processor.output(nil, fnames1[:presentationxml], fnames1[:out], ext, ) wrap_html(, fnames1[:ext], fnames1[:out]) rescue StandardError => e isodoc_error_process(e) end |
#process_output_unthreaded(ext, fnames, isodoc, isodoc_options) ⇒ Object
156 157 158 159 160 161 162 |
# File 'lib/metanorma/compile.rb', line 156 def process_output_unthreaded(ext, fnames, isodoc, ) @processor.output(isodoc, fnames[:xml], fnames[:out], ext, ) nil # return as Thread rescue StandardError => e isodoc_error_process(e) end |
#read_file(filename) ⇒ Object
69 70 71 |
# File 'lib/metanorma/compile.rb', line 69 def read_file(filename) File.read(filename, encoding: "utf-8").gsub("\r\n", "\n") end |
#recursive_string_keys(hash) ⇒ Object
213 214 215 216 217 218 219 220 |
# File 'lib/metanorma/sectionsplit.rb', line 213 def recursive_string_keys(hash) case hash when Hash then hash.map { |k, v| [k.to_s, recursive_string_keys(v)] }.to_h when Enumerable then hash.map { |v| recursive_string_keys(v) } else hash end end |
#relaton_export(isodoc, options) ⇒ Object
73 74 75 76 77 78 79 80 81 |
# File 'lib/metanorma/compile.rb', line 73 def relaton_export(isodoc, ) return unless [:relaton] xml = Nokogiri::XML(isodoc) { |config| config.huge } bibdata = xml.at("//bibdata") || xml.at("//xmlns:bibdata") # docid = bibdata&.at("./xmlns:docidentifier")&.text || options[:filename] # outname = docid.sub(/^\s+/, "").sub(/\s+$/, "").gsub(/\s+/, "-") + ".xml" File.open([:relaton], "w:UTF-8") { |f| f.write bibdata.to_xml } end |
#require_libraries(options) ⇒ Object
5 6 7 |
# File 'lib/metanorma/compile_options.rb', line 5 def require_libraries() &.dig(:require)&.each { |r| require r } end |
#requirement_export(xml, dirname) ⇒ Object
62 63 64 65 66 67 68 69 70 |
# File 'lib/metanorma/extract.rb', line 62 def requirement_export(xml, dirname) xml.at(REQUIREMENT_XPATH) or return FileUtils.mkdir_p "#{dirname}/requirement" xml.xpath(REQUIREMENT_XPATH).each_with_index do |s, i| fn = s["filename"] || sprintf("%<name>s-%<num>04d.xml", name: s.name, num: i) export_output("#{dirname}/requirement/#{fn}", s) end end |
#sectionfile(fulldoc, xml, file, chunk, parentnode) ⇒ Object
85 86 87 88 89 |
# File 'lib/metanorma/sectionsplit.rb', line 85 def sectionfile(fulldoc, xml, file, chunk, parentnode) fname = create_sectionfile(fulldoc, xml.dup, file, chunk, parentnode) { order: chunk["displayorder"].to_i, url: fname, title: titlerender(chunk) } end |
#sectionsplit(xml, filename, dir) ⇒ Object
65 66 67 68 69 70 71 72 73 74 |
# File 'lib/metanorma/sectionsplit.rb', line 65 def sectionsplit(xml, filename, dir) @key = xref_preprocess(xml) @splitdir = dir out = emptydoc(xml) SPLITSECTIONS.each_with_object([]) do |n, ret| xml.xpath(ns(n[0])).each do |s| ret << sectionfile(xml, out, "#{filename}.#{ret.size}", s, n[1]) end end end |
#sectionsplit_convert(input_filename, file, output_filename = nil, opts = {}) ⇒ Object
assume we pass in Presentation XML, but we want to recover Semantic XML
6 7 8 9 10 11 12 13 14 15 16 |
# File 'lib/metanorma/sectionsplit.rb', line 6 def sectionsplit_convert(input_filename, file, output_filename = nil, opts = {}) @isodoc = IsoDoc::Convert.new({}) input_filename += ".xml" unless input_filename.match?(/\.xml$/) File.exist?(input_filename) or File.open(input_filename, "w:UTF-8") { |f| f.write(file) } presxml = File.read(input_filename, encoding: "utf-8") @openmathdelim, @closemathdelim = @isodoc.extract_delims(presxml) xml, filename, dir = @isodoc.convert_init(presxml, input_filename, false) build_collection(xml, presxml, output_filename || filename, dir, opts) end |
#sourcecode_export(xml, dirname) ⇒ Object
34 35 36 37 38 39 40 41 42 |
# File 'lib/metanorma/extract.rb', line 34 def sourcecode_export(xml, dirname) xml.at("//sourcecode | //xmlns:sourcecode") or return FileUtils.mkdir_p "#{dirname}/sourcecode" xml.xpath("//sourcecode | //xmlns:sourcecode").each_with_index do |s, i| filename = s["filename"] || sprintf("sourcecode-%04d.txt", i) export_output("#{dirname}/sourcecode/#{filename}", clean_sourcecode(s.dup)) end end |
#svg_preprocess(xml) ⇒ Object
119 120 121 122 123 124 125 126 127 128 129 130 |
# File 'lib/metanorma/sectionsplit.rb', line 119 def svg_preprocess(xml) xml.xpath("//m:svg", "m" => "http://www.w3.org/2000/svg").each do |s| m = svgmap_wrap(s) s.xpath(".//m:a", "m" => "http://www.w3.org/2000/svg").each do |a| next unless /^#/.match? a["href"] a["href"] = a["href"].sub(/^#/, "") m << "<target href='#{a['href']}'>"\ "<xref target='#{a['href']}'/></target>" end end end |
#svgmap_wrap(svg) ⇒ Object
132 133 134 135 136 137 |
# File 'lib/metanorma/sectionsplit.rb', line 132 def svgmap_wrap(svg) ret = svg.at("./ancestor::xmlns:svgmap") and return ret ret = svg.at("./ancestor::xmlns:figure") ret.wrap("<svgmap/>") svg.at("./ancestor::xmlns:svgmap") end |
#titlerender(section) ⇒ Object
222 223 224 225 226 227 228 |
# File 'lib/metanorma/sectionsplit.rb', line 222 def titlerender(section) title = section.at(ns("./title")) or return "[Untitled]" t = title.dup t.xpath(ns(".//tab | .//br")).each { |x| x.replace(" ") } t.xpath(ns(".//strong")).each { |x| x.replace(x.children) } t.children.to_xml end |
#validate_format(options) ⇒ Object
17 18 19 20 21 22 |
# File 'lib/metanorma/compile_validate.rb', line 17 def validate_format() unless [:format] == :asciidoc Util.log("[metanorma] Error: Only source file format currently "\ "supported is 'asciidoc'.", :fatal) end end |
#validate_options(options) ⇒ Object
3 4 5 6 |
# File 'lib/metanorma/compile_validate.rb', line 3 def () validate_type() validate_format() end |
#validate_type(options) ⇒ Object
8 9 10 11 12 13 14 15 |
# File 'lib/metanorma/compile_validate.rb', line 8 def validate_type() unless [:type] Util.log("[metanorma] Error: Please specify a standard type: "\ "#{@registry.supported_backends}.", :fatal) end stdtype = [:type].to_sym load_flavor(stdtype) end |
#wrap_html(options, file_extension, outfilename) ⇒ Object
88 89 90 91 92 93 94 95 |
# File 'lib/metanorma/compile.rb', line 88 def wrap_html(, file_extension, outfilename) if [:wrapper] && /html$/.match(file_extension) outfilename = outfilename.sub(/\.html$/, "") FileUtils.mkdir_p outfilename FileUtils.mv "#{outfilename}.html", outfilename FileUtils.mv "#{outfilename}_images", outfilename, force: true end end |
#xml_options_extract(file) ⇒ Object
9 10 11 12 13 14 15 16 17 |
# File 'lib/metanorma/compile_options.rb', line 9 def (file) xml = Nokogiri::XML(file) { |config| config.huge } if xml.root @registry..each do |k, v| return { type: k } if v == xml.root.name end end {} end |
#xref_preprocess(xml) ⇒ Object
104 105 106 107 108 109 |
# File 'lib/metanorma/sectionsplit.rb', line 104 def xref_preprocess(xml) svg_preprocess(xml) key = (0...8).map { rand(65..90).chr }.join # random string xml.root["type"] = key # to force recognition of internal refs key end |
#xref_process(section, xml, key) ⇒ Object
111 112 113 114 115 116 117 |
# File 'lib/metanorma/sectionsplit.rb', line 111 def xref_process(section, xml, key) refs = eref_to_internal_eref(section, xml, key) refs += xref_to_internal_eref(section, key) ins = new_hidden_ref(section) copied_refs = copy_repo_items_biblio(ins, section, xml) insert_indirect_biblio(ins, refs - copied_refs, key) end |
#xref_to_internal_eref(xml, key) ⇒ Object
144 145 146 147 148 149 150 151 152 153 |
# File 'lib/metanorma/sectionsplit.rb', line 144 def xref_to_internal_eref(xml, key) xml.xpath(ns("//xref")).each_with_object({}) do |x, m| x["bibitemid"] = "#{key}_#{x['target']}" x << make_anchor(x["target"]) m[x["bibitemid"]] = true x.delete("target") x["type"] = key x.name = "eref" end.keys end |