Class: Rouge::CLI::Highlight

Inherits:
Rouge::CLI show all
Defined in:
lib/rouge/cli.rb

Direct Known Subclasses

Debug

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Methods inherited from Rouge::CLI

class_from_arg, error!, #error!

Constructor Details

#initialize(opts = {}) ⇒ Highlight

Returns a new instance of Highlight.



307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
 
# File 'lib/rouge/cli.rb', line 307

def initialize(opts={})
  Rouge::Lexer.enable_debug!

  opts[:requires].each do |r|
    require r
  end

  @input_file = opts[:input_file]

  if opts[:lexer]
    @lexer_class = Lexer.find(opts[:lexer]) \
      or error! "unknown lexer #{opts[:lexer].inspect}"
  else
    @lexer_name = opts[:lexer]
    @mimetype = opts[:mimetype]
  end

  @lexer_opts = opts[:lexer_opts]

  theme = Theme.find(opts[:theme]).new or error! "unknown theme #{opts[:theme]}"

  # TODO: document this in --help
  @formatter = case opts[:formatter]
  when 'terminal256' then Formatters::Terminal256.new(theme)
  when 'terminal-truecolor' then Formatters::TerminalTruecolor.new(theme)
  when 'html' then Formatters::HTML.new
  when 'html-pygments' then Formatters::HTMLPygments.new(Formatters::HTML.new, opts[:css_class])
  when 'html-inline' then Formatters::HTMLInline.new(theme)
  when 'html-line-table' then Formatters::HTMLLineTable.new(Formatters::HTML.new)
  when 'html-table' then Formatters::HTMLTable.new(Formatters::HTML.new)
  when 'null', 'raw', 'tokens' then Formatters::Null.new
  when 'tex' then Formatters::Tex.new
  else
    error! "unknown formatter preset #{opts[:formatter]}"
  end

  @escape = opts[:escape]
end

Instance Attribute Details

#escape ⇒ Object (readonly)

Returns the value of attribute escape.



305
306
307
 
# File 'lib/rouge/cli.rb', line 305

def escape
  @escape
end

#formatter ⇒ Object (readonly)

Returns the value of attribute formatter.



305
306
307
 
# File 'lib/rouge/cli.rb', line 305

def formatter
  @formatter
end

#input_file ⇒ Object (readonly)

Returns the value of attribute input_file.



305
306
307
 
# File 'lib/rouge/cli.rb', line 305

def input_file
  @input_file
end

#lexer_name ⇒ Object (readonly)

Returns the value of attribute lexer_name.



305
306
307
 
# File 'lib/rouge/cli.rb', line 305

def lexer_name
  @lexer_name
end

#mimetype ⇒ Object (readonly)

Returns the value of attribute mimetype.



305
306
307
 
# File 'lib/rouge/cli.rb', line 305

def mimetype
  @mimetype
end

Class Method Details

.desc ⇒ Object 



168
169
170
 
# File 'lib/rouge/cli.rb', line 168

def self.desc
  "highlight code"
end

.doc {|%[usage: rougify highlight <filename> [options...]]| ... } ⇒ Object

Yields:

  • (%[usage: rougify highlight <filename> [options...]]) 


172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
 
# File 'lib/rouge/cli.rb', line 172

def self.doc
  return enum_for(:doc) unless block_given?

  yield %[usage: rougify highlight <filename> [options...]]
  yield %[       rougify highlight [options...]]
  yield %[]
  yield %[--input-file|-i <filename>   specify a file to read, or - to use stdin]
  yield %[]
  yield %[--lexer|-l <lexer>           specify the lexer to use.]
  yield %[                             If not provided, rougify will try to guess]
  yield %[                             based on --mimetype, the filename, and the]
  yield %[                             file contents.]
  yield %[]
  yield %[--formatter-preset|-f <opts> specify the output formatter to use.]
  yield %[                             If not provided, rougify will default to]
  yield %[                             terminal256. options are: terminal256,]
  yield %[                             terminal-truecolor, html, html-pygments,]
  yield %[                             html-inline, html-line-table, html-table,]
  yield %[                             null/raw/tokens, or tex.]
  yield %[]
  yield %[--theme|-t <theme>           specify the theme to use for highlighting]
  yield %[                             the file. (only applies to some formatters)]
  yield %[]
  yield %[--mimetype|-m <mimetype>     specify a mimetype for lexer guessing]
  yield %[]
  yield %[--lexer-opts|-L <opts>       specify lexer options in CGI format]
  yield %[                             (opt1=val1&opt2=val2)]
  yield %[]
  yield %[--formatter-opts|-F <opts>   specify formatter options in CGI format]
  yield %[                             (opt1=val1&opt2=val2)]
  yield %[]
  yield %[--require|-r <filename>      require a filename or library before]
  yield %[                             highlighting]
  yield %[]
  yield %[--escape                     allow the use of escapes between <! and !>]
  yield %[]
  yield %[--escape-with <l> <r>        allow the use of escapes between custom]
  yield %[                             delimiters. implies --escape]
end

.parse(argv) ⇒ Object 



269
270
271
 
# File 'lib/rouge/cli.rb', line 269

def self.parse(argv)
  new(parse_opts(argv))
end

.parse_opts(argv) ⇒ Object 



225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
 
# File 'lib/rouge/cli.rb', line 225

def self.parse_opts(argv)
  opts = {
    :formatter => supports_truecolor? ? 'terminal-truecolor' : 'terminal256',
    :theme => 'thankful_eyes',
    :css_class => 'codehilite',
    :input_file => '-',
    :lexer_opts => {},
    :formatter_opts => {},
    :requires => [],
  }

  until argv.empty?
    arg = argv.shift
    case arg
    when '-r', '--require'
      opts[:requires] << argv.shift
    when '--input-file', '-i'
      opts[:input_file] = argv.shift
    when '--mimetype', '-m'
      opts[:mimetype] = argv.shift
    when '--lexer', '-l'
      opts[:lexer] = argv.shift
    when '--formatter-preset', '-f'
      opts[:formatter] = argv.shift
    when '--theme', '-t'
      opts[:theme] = argv.shift
    when '--css-class', '-c'
      opts[:css_class] = argv.shift
    when '--lexer-opts', '-L'
      opts[:lexer_opts] = parse_cgi(argv.shift)
    when '--escape'
      opts[:escape] = ['<!', '!>']
    when '--escape-with'
      opts[:escape] = [argv.shift, argv.shift]
    when /^--/
      error! "unknown option #{arg.inspect}"
    else
      opts[:input_file] = arg
    end
  end

  opts
end

.supports_truecolor? ⇒ Boolean

There is no consistent way to do this, but this is used elsewhere, and we provide explicit opt-in and opt-out with $COLORTERM

Returns:

  • (Boolean) 


214
215
216
217
218
219
220
221
222
223
 
# File 'lib/rouge/cli.rb', line 214

def self.supports_truecolor?
  return true if %w(24bit truecolor).include?(ENV['COLORTERM'])
  return false if ENV['COLORTERM'] && ENV['COLORTERM'] =~ /256/

  if RbConfig::CONFIG['host_os'] =~ /mswin|mingw/
    ENV['ConEmuANSI'] == 'ON' && !ENV['ANSICON']
  else
    ENV['TERM'] !~ /(^rxvt)|(-color$)/
  end
end

Instance Method Details

#escape_lexer ⇒ Object 



293
294
295
296
297
298
299
 
# File 'lib/rouge/cli.rb', line 293

def escape_lexer
  Rouge::Lexers::Escape.new(
    start: @escape[0],
    end: @escape[1],
    lang: raw_lexer,
  )
end

#input ⇒ Object 



277
278
279
 
# File 'lib/rouge/cli.rb', line 277

def input
  @input ||= input_stream.read
end

#input_stream ⇒ Object 



273
274
275
 
# File 'lib/rouge/cli.rb', line 273

def input_stream
  @input_stream ||= FileReader.new(@input_file)
end

#lexer ⇒ Object 



301
302
303
 
# File 'lib/rouge/cli.rb', line 301

def lexer
  @lexer ||= @escape ? escape_lexer : raw_lexer
end

#lexer_class ⇒ Object 



281
282
283
284
285
286
287
 
# File 'lib/rouge/cli.rb', line 281

def lexer_class
  @lexer_class ||= Lexer.guess(
    :filename => @input_file,
    :mimetype => @mimetype,
    :source => input_stream,
  )
end

#raw_lexer ⇒ Object 



289
290
291
 
# File 'lib/rouge/cli.rb', line 289

def raw_lexer
  lexer_class.new(@lexer_opts)
end

#run ⇒ Object 



346
347
348
349
 
# File 'lib/rouge/cli.rb', line 346

def run
  Formatter.enable_escape! if @escape
  formatter.format(lexer.lex(input), &method(:print))
end