Module: Metanorma::Compile::CompileOptions

Included in:
Metanorma::Compile
Defined in:
lib/metanorma/compile/compile_options.rb

Instance Method Summary collapse

Instance Method Details

#effective_output_formats(options) ⇒ Object

The processor's output formats merged with the suffixes of any taste-contributed document-model formats, so those formats pass extension validation and get an output suffix.



80
81
82
83
84
85
 
# File 'lib/metanorma/compile/compile_options.rb', line 80

def effective_output_formats(options)
  @processor.output_formats.merge(
    taste_transformers(options)
      .transform_values { |spec| spec[:suffix] }.compact,
  )
end

#extract_dir_options(options, options_in_file, filename) ⇒ Object 



54
55
56
57
58
59
60
61
62
63
 
# File 'lib/metanorma/compile/compile_options.rb', line 54

def extract_dir_options(options, options_in_file, filename)
  filename.is_a?(Tempfile) and return
  dir = filename.sub(%r(/[^/]+$), "/")
  options_in_file[:relaton] and
    options[:relaton] ||= File.join(dir,
                                    options_in_file[:relaton])
  options_in_file[:sourcecode] and
    options[:sourcecode] ||= File.join(dir,
                                       options_in_file[:sourcecode])
end

#extract_extension_options(opt, doc_opt) ⇒ Object 



32
33
34
35
36
37
38
39
 
# File 'lib/metanorma/compile/compile_options.rb', line 32

def extract_extension_options(opt, doc_opt)
  opt[:extension_keys] == [:all] and opt[:extension_keys] = []
  ext = opt[:extension_keys] || []
  doc_opt[:extensions] == "all" and doc_opt[:extensions] = ""
  ext1 = (doc_opt[:extensions] || "").split(/, */).map(&:to_sym)
  !ext1.empty? && ext.empty? and opt[:extension_keys] = ext1
  opt[:extension_keys]&.empty? and opt[:extension_keys] = nil
end

#extract_extensions(options) ⇒ Object 



104
105
106
107
108
109
110
111
112
113
114
115
 
# File 'lib/metanorma/compile/compile_options.rb', line 104

def extract_extensions(options)
  formats = effective_output_formats(options)
  options[:extension_keys] ||=
    formats.reduce([]) { |memo, (k, _)| memo << k }
  options[:extension_keys].reduce([]) do |memo, e|
    if formats[e] then memo << e
    else
      unsupported_format_error(e)
      memo
    end
  end
end

#extract_flavor_options(options, options_in_file) ⇒ Object 



47
48
49
50
51
52
 
# File 'lib/metanorma/compile/compile_options.rb', line 47

def extract_flavor_options(options, options_in_file)
  options[:type] ||= options_in_file[:type]
  options[:type] = options[:type]&.to_sym
  options[:supplied_type] = options[:type]
  t = @registry.alias(options[:type]) and options[:type] = t
end

#extract_options(filename, options) ⇒ Object 



20
21
22
23
24
25
26
27
28
29
30
 
# File 'lib/metanorma/compile/compile_options.rb', line 20

def extract_options(filename, options)
  o = options_in_file(filename)
  extract_flavor_options(options, o)
  extract_dir_options(options, o, filename)
  extract_extension_options(options, o)
  options[:format] ||= :asciidoc
  options[:filename] = filename
  options[:fontlicenseagreement] ||= "no-install-fonts"
  options[:novalid] = o[:novalid] if o[:novalid]
  options
end

#extract_xml_options(file) ⇒ Object 



10
11
12
13
14
15
16
17
18
 
# File 'lib/metanorma/compile/compile_options.rb', line 10

def extract_xml_options(file)
  xml = Nokogiri::XML(file, &:huge)
  if xml.root
    @registry.root_tags.each do |k, v|
      return { type: k } if v == xml.root.name
    end
  end
  {}
end

#font_install(opt) ⇒ Object 



117
118
119
120
121
 
# File 'lib/metanorma/compile/compile_options.rb', line 117

def font_install(opt)
  @fontist_installed or
    Util::FontistHelper.install_fonts(@processor, opt)
  @fontist_installed = true
end

#get_extensions(options) ⇒ Object 



94
95
96
97
98
99
100
101
102
 
# File 'lib/metanorma/compile/compile_options.rb', line 94

def get_extensions(options)
  ext = extract_extensions(options)
  !ext.include?(:presentation) && ext.any? do |e|
    uses_presentation_xml?(e, options)
  end and ext << :presentation
  !ext.include?(:rxl) && options[:site_generate] and
    ext << :rxl
  ext
end

#options_in_file(filename) ⇒ Object 



41
42
43
44
45
 
# File 'lib/metanorma/compile/compile_options.rb', line 41

def options_in_file(filename)
  content = read_file(filename)
  Metanorma::Input::Asciidoc.new.extract_metanorma_options(content)
    .merge(extract_xml_options(content))
end

#require_libraries(options) ⇒ Object 



6
7
8
 
# File 'lib/metanorma/compile/compile_options.rb', line 6

def require_libraries(options)
  options&.dig(:require)&.each { |r| require r }
end

#taste_transformers(options) ⇒ Object

Document-model transformer specs contributed by the active taste (+options+), or {}. Lets a taste (e.g. OIML) make its own output format selectable and choose its presentation/semantic leg, via the taste-aware metanorma-core Processor (metanorma-core#12).



69
70
71
72
73
74
75
 
# File 'lib/metanorma/compile/compile_options.rb', line 69

def taste_transformers(options)
  taste = options[:supplied_type]
  return {} unless taste && defined?(Metanorma::TasteRegister) &&
    Metanorma::TasteRegister.respond_to?(:document_transformers_for)

  Metanorma::TasteRegister.document_transformers_for(taste) || {}
end

#uses_presentation_xml?(ext, options) ⇒ Boolean

Whether ext is generated from presentation XML, honouring both the processor's own answer and a taste transformer's :presentation flag.

Returns:

  • (Boolean) 


89
90
91
92
 
# File 'lib/metanorma/compile/compile_options.rb', line 89

def uses_presentation_xml?(ext, options)
  @processor.use_presentation_xml(ext) ||
    (taste_transformers(options)[ext] || {})[:presentation] == true
end