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 the ‘softcover.sty’ file. We also support custom overrides in ‘custom_pdf.sty’.



187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
 
# File 'lib/polytexnic/utils.rb', line 187

def add_font_info(string)
  softcover_sty  = File.join('latex_styles', 'softcover.sty')
  custom_pdf_sty = File.join('latex_styles', 'custom_pdf.sty')
  regex = '{code}{Verbatim}{(.*)}'
  styles = nil
  [softcover_sty, custom_pdf_sty].reverse.each do |filename|
    if File.exist?(filename)
      styles ||= File.read(filename).scan(/#{regex}/).flatten.first
    end
  end
  unless styles.nil?
    string.gsub!("\\begin{Verbatim}[",
                 "\\begin{Verbatim}[#{styles},")
  end
  string
end

#cache_hrefs(doc, latex = false) ⇒ Object

Caches URLs for href commands.



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

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.

Returns:

  • (Boolean) 


223
224
225
 
# File 'lib/polytexnic/utils.rb', line 223

def debug?
  false
end

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

Returns a salted hash digest of the string.



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

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.



67
68
69
 
# File 'lib/polytexnic/utils.rb', line 67

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

#framed(code) ⇒ Object

Puts a frame around code.



164
165
166
 
# File 'lib/polytexnic/utils.rb', line 164

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

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

Highlights a code sample.



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

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.



152
153
154
155
156
 
# File 'lib/polytexnic/utils.rb', line 152

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

#highlight_source_code(document) ⇒ Object

Highlights source code.



124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
 
# File 'lib/polytexnic/utils.rb', line 124

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.



159
160
161
 
# File 'lib/polytexnic/utils.rb', line 159

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`.



217
218
219
 
# File 'lib/polytexnic/utils.rb', line 217

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

#linux? ⇒ Boolean

Returns true if platform is Linux.

Returns:

  • (Boolean) 


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

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

#os_x? ⇒ Boolean

Returns true if platform is OS X.

Returns:

  • (Boolean) 


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

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

#os_x_newer? ⇒ Boolean

Returns true for OS X Mountain Lion (10.8) and later.

Returns:

  • (Boolean) 


25
26
27
 
# File 'lib/polytexnic/utils.rb', line 25

def os_x_newer?
  os_x? && !os_x_older?
end

#os_x_older? ⇒ Boolean

Returns true for OS X Lion (10.7) and earlier.

Returns:

  • (Boolean) 


30
31
32
 
# File 'lib/polytexnic/utils.rb', line 30

def os_x_older?
  os_x? && RUBY_PLATFORM.include?('11')
end

#pipeline_digest(element) ⇒ Object

Returns a digest for passing things through the pipeline.



51
52
53
54
 
# File 'lib/polytexnic/utils.rb', line 51

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.

Returns:

  • (Boolean) 


229
230
231
232
 
# File 'lib/polytexnic/utils.rb', line 229

def profiling?
  return false if test?
  false
end

#set_test_mode! ⇒ Object 



234
235
236
 
# File 'lib/polytexnic/utils.rb', line 234

def set_test_mode!
  @@test_mode = true
end

#test? ⇒ Boolean

Returns:

  • (Boolean) 


238
239
240
 
# File 'lib/polytexnic/utils.rb', line 238

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
21
22
 
# File 'lib/polytexnic/utils.rb', line 10

def tralics
  filename = if os_x_newer?
               'tralics-os-x-newer'
             elsif os_x_older?
               'tralics-os-x-older'
             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.



97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
 
# File 'lib/polytexnic/utils.rb', line 97

def tralics_commands
  base_commands = <<-'EOS'
% Commands specific to Tralics
\def\hyperref[#1]#2{\xmlelt{a}{\XMLaddatt{target}{#1}#2}}
\newcommand{\heading}[1]{\xmlelt{heading}{#1}}
\newcommand{\codecaption}[1]{\xmlelt{heading}{#1}}
\newcommand{\sout}[1]{\xmlelt{sout}{#1}}
\newcommand{\kode}[1]{\xmlelt{kode}{#1}}
\newcommand{\filepath}[1]{\xmlelt{filepath}{#1}}
\newcommand{\image}[1]{\xmlelt{image}{#1}}
\newcommand{\imagebox}[1]{\xmlelt{imagebox}{#1}}
% Ignore pbox argument, just replacing with content.
\newcommand{\pbox}[2]{#2}
% Ignore some other commands.
\newcommand{\includepdf}[1]{}
\newcommand{\newunicodechar}[2]{fdsfdas}
  EOS
  custom_commands = <<-EOS
\\usepackage{amsthm}
\\theoremstyle{definition}
\\newtheorem{codelisting}{#{language_labels["listing"]}}[chapter]
\\newtheorem{aside}{#{language_labels["aside"]}}[chapter]
  EOS
  [base_commands, custom_commands].join("\n")
end

#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.



59
60
61
 
# File 'lib/polytexnic/utils.rb', line 59

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.



86
87
88
89
90
 
# File 'lib/polytexnic/utils.rb', line 86

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