Module: Polytexnic::Utils

Extended by:
Utils
Included in:
Pipeline, Utils
Defined in:
lib/polytexnic/utils.rb

Instance Method Summary collapse

Instance Method Details

#add_font_info(string) ⇒ Object

Adds some verbatim font info (including size). We prepend rather than replace the styles because the Pygments output includes a required override of the default commandchars. Since the substitution is only important in the context of a PDF book, it only gets made if there’s a style in ‘softcover.sty’ in the current directory



169
170
171
172
173
174
175
176
177
 
# File 'lib/polytexnic/utils.rb', line 169

def add_font_info(string)
  if File.exist?('softcover.sty')
    regex = '{code}{Verbatim}{(.*)}'
    styles = File.read('softcover.sty').scan(/#{regex}/).flatten.first
    string.gsub!("\\begin{Verbatim}[",
                 "\\begin{Verbatim}[#{styles},")
  end
  string
end

#cache_hrefs(doc, latex = false) ⇒ Object

Caches URLs for href commands.



60
61
62
63
64
65
66
67
68
 
# File 'lib/polytexnic/utils.rb', line 60

def cache_hrefs(doc, latex=false)
  doc.tap do |text|
    text.gsub!(/\\href{(.*?)}/) do
      key = digest($1)
      literal_cache[key] = $1
      "\\href{#{key}}"
    end
  end
end

#debug? ⇒ Boolean

Returns true if we are debugging, false otherwise. Manually change to ‘true` on an as-needed basis.



198
199
200
 
# File 'lib/polytexnic/utils.rb', line 198

def debug?
  false
end

#digest(string, options = {}) ⇒ Object

Returns a salted hash digest of the string.



33
34
35
36
 
# File 'lib/polytexnic/utils.rb', line 33

def digest(string, options = {})
  salt = options[:salt] || SecureRandom.base64
  Digest::SHA1.hexdigest("#{salt}--#{string}")
end

#escape_backslashes(string) ⇒ Object

Escapes backslashes. Interpolated backslashes need extra escaping. We only escape ‘\’ by itself, i.e., a backslash followed by spaces or the end of line.



55
56
57
 
# File 'lib/polytexnic/utils.rb', line 55

def escape_backslashes(string)
  string.gsub(/\\(\s+|$)/) { '\\\\' + $1.to_s }
end

#framed(code) ⇒ Object

Puts a frame around code.



146
147
148
 
# File 'lib/polytexnic/utils.rb', line 146

def framed(code)
  "\\begin{framed_shaded}\n#{code}\n\\end{framed_shaded}"
end

#highlight(key, content, language, formatter, options) ⇒ Object

Highlights a code sample.



151
152
153
154
155
156
157
158
159
160
161
 
# File 'lib/polytexnic/utils.rb', line 151

def highlight(key, content, language, formatter, options)
  require 'pygments'
  options = JSON.parse('{' + options.to_s + '}')
  if options['linenos'] && formatter == 'html'
    # Inline numbers look much better in HTML but are invalid in LaTeX.
    options['linenos'] = 'inline'
  end
  highlight_cache[key] ||= Pygments.highlight(content, lexer: language,
                                                       formatter: formatter,
                                                       options: options)
end

#highlight_lines(output, options) ⇒ Object

Highlight lines (i.e., with a yellow backgroun). This is needed due to a Pygments bug that fails to highlight lines in the LaTeX output.



134
135
136
137
138
 
# File 'lib/polytexnic/utils.rb', line 134

def highlight_lines(output, options)
  highlighted_lines(options).each do |i|
    output[i] = '\ccolorbox{hilightyellow}{' + output[i] + '}'
  end
end

#highlight_source_code(document) ⇒ Object

Highlights source code.



106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
 
# File 'lib/polytexnic/utils.rb', line 106

def highlight_source_code(document)
  if document.is_a?(String) # LaTeX
    substitutions = {}
    document.tap do
      code_cache.each do |key, (content, language, in_codelisting, options)|
        code   = highlight(key, content, language, 'latex', options)
        output = code.split("\n")
        horrible_backslash_kludge(add_font_info(output.first))
        highlight_lines(output, options)
        code = output.join("\n")
        substitutions[key] = in_codelisting ? code : framed(code)
      end
      document.gsub!(Regexp.union(substitutions.keys), substitutions)
    end
  else # HTML
    document.css('div.code').each do |code_block|
      key = code_block.content
      next unless (value = code_cache[key])
      content, language, _, options = value
      code_block.inner_html = highlight(key, content, language, 'html',
                                        options)
    end
  end
end

#highlighted_lines(options) ⇒ Object

Returns an array with the highlighted lines.



141
142
143
 
# File 'lib/polytexnic/utils.rb', line 141

def highlighted_lines(options)
  JSON.parse('{' + options.to_s + '}')['hl_lines'] || []
end

#horrible_backslash_kludge(string) ⇒ Object

Does something horrible with backslashes. OK, so the deal is that code highlighted for LaTeX contains the line beginVerbatim Oh crap, there are backslashes in there. This means we have no chance of getting things to work after interpolating, gsubbing, and so on, because in Ruby ‘\foo’ is the same as ‘\\foo’, ‘}’ is ‘}’, etc. I thought I escaped (heh) this problem with the ‘escape_backslashes` method, but here the problem is extremely specific. In particular, \{} is really \ and { and }, but Ruby doensn’t know WTF to do with it, and thinks that it’s “\{}”, which is the same as ‘{}’. The solution is to replace ‘\\’ with some number of backslashes. How many? I literally had to just keep adding backslashes until the output was correct when running ‘softcover build:pdf`.



192
193
194
 
# File 'lib/polytexnic/utils.rb', line 192

def horrible_backslash_kludge(string)
  string.gsub!(/commandchars=\\\\/, 'commandchars=\\\\\\\\')
end

#linux? ⇒ Boolean

Returns true if platform is Linux.



28
29
30
 
# File 'lib/polytexnic/utils.rb', line 28

def linux?
  RUBY_PLATFORM.match(/linux/)
end

#os_x? ⇒ Boolean

Returns true if platform is OS X.



23
24
25
 
# File 'lib/polytexnic/utils.rb', line 23

def os_x?
  RUBY_PLATFORM.match(/darwin/)
end

#pipeline_digest(element) ⇒ Object

Returns a digest for passing things through the pipeline.



39
40
41
42
 
# File 'lib/polytexnic/utils.rb', line 39

def pipeline_digest(element)
  value = digest("#{Time.now.to_s}::#{element}")
  @literal_cache[element.to_s] ||= value
end

#profiling? ⇒ Boolean

Returns true if we are profiling the code, false otherwise. Manually change to ‘true` on an as-needed basis.



204
205
206
207
 
# File 'lib/polytexnic/utils.rb', line 204

def profiling?
  return false if test?
  false
end

#set_test_mode! ⇒ Object 



209
210
211
 
# File 'lib/polytexnic/utils.rb', line 209

def set_test_mode!
  @@test_mode = true
end

#test? ⇒ Boolean 



213
214
215
 
# File 'lib/polytexnic/utils.rb', line 213

def test?
  defined?(@@test_mode) && @@test_mode
end

#tralics ⇒ Object

Returns the executable for the Tralics LaTeX-to-XML converter.



10
11
12
13
14
15
16
17
18
19
20
 
# File 'lib/polytexnic/utils.rb', line 10

def tralics
  filename = if os_x?
               'tralics-os-x'
             elsif linux?
               'tralics-linux'
             else
               raise "Platform #{RUBY_PLATFORM} not supported"
             end
  project_root = File.join(File.dirname(__FILE__), '..', '..')
  File.join(project_root, 'precompiled_binaries', filename)
end

#tralics_commands ⇒ Object

Returns some commands for Tralics. For various reasons, we don’t actually want to include these in the style file that gets passed to LaTeX. For example, the commands with ‘xmlelt’ aren’t even valid LaTeX; they’re actually pseudo-LaTeX that has special meaning to the Tralics processor.



85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
 
# File 'lib/polytexnic/utils.rb', line 85

def tralics_commands
  "% Commands specific to Tralics\n\\def\\hyperref[#1]#2{\\xmlelt{a}{\\XMLaddatt{target}{#1}#2}}\n\\newcommand{\\heading}[1]{\\xmlelt{heading}{#1}}\n\\newcommand{\\codecaption}[1]{\\xmlelt{heading}{#1}}\n\\newcommand{\\sout}[1]{\\xmlelt{sout}{#1}}\n\\newcommand{\\kode}[1]{\\xmlelt{kode}{#1}}\n\\newcommand{\\filepath}[1]{\\xmlelt{filepath}{#1}}\n\\newcommand{\\image}[1]{\\xmlelt{image}{#1}}\n\\newcommand{\\imagebox}[1]{\\xmlelt{imagebox}{#1}}\n\n% Code listings\n\\usepackage{amsthm}\n\\theoremstyle{definition}\n\\newtheorem{codelisting}{Listing}[chapter]\n\\newtheorem{aside}{Box}[chapter]\n  EOS\nend\n"

#underscore_digest ⇒ Object

Returns a digest for use in labels. I like to use labels of the form cha:foo_bar, but for some reason Tralics removes the underscore in this case.



47
48
49
 
# File 'lib/polytexnic/utils.rb', line 47

def underscore_digest
  pipeline_digest('_')
end

#xmlelement(name, skip = false) ⇒ Object

Returns a Tralics pseudo-LaTeX XML element. The use of the ‘skip’ flag is a hack to be able to use xmlelement even when generating, e.g., LaTeX, where we simply want to yield the block.



74
75
76
77
78
 
# File 'lib/polytexnic/utils.rb', line 74

def xmlelement(name, skip = false)
  output = (skip ? "" : "\\begin{xmlelement}{#{name}}")
  output << yield if block_given?
  output << (skip ? "" : "\\end{xmlelement}")
end