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!, normalize_syntax

Constructor Details

#initialize(opts = {}) ⇒ Highlight

Returns a new instance of Highlight.



303
304
305
306
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
# File 'lib/rouge/cli.rb', line 303

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

#escapeObject (readonly)

Returns the value of attribute escape.



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

def escape
  @escape
end

#formatterObject (readonly)

Returns the value of attribute formatter.



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

def formatter
  @formatter
end

#input_fileObject (readonly)

Returns the value of attribute input_file.



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

def input_file
  @input_file
end

#lexer_nameObject (readonly)

Returns the value of attribute lexer_name.



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

def lexer_name
  @lexer_name
end

#mimetypeObject (readonly)

Returns the value of attribute mimetype.



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

def mimetype
  @mimetype
end

Class Method Details

.descObject



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

def self.desc
  "highlight code"
end

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

Yields:

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


171
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
# File 'lib/rouge/cli.rb', line 171

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|-f <opts>       specify the output formatter to use.]
  yield %[                            If not provided, rougify will default to]
  yield %[                            terminal256.]
  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



265
266
267
# File 'lib/rouge/cli.rb', line 265

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

.parse_cgi(str) ⇒ Object



348
349
350
351
# File 'lib/rouge/cli.rb', line 348

def self.parse_cgi(str)
  pairs = CGI.parse(str).map { |k, v| [k.to_sym, v.first] }
  Hash[pairs]
end

.parse_opts(argv) ⇒ Object



221
222
223
224
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
# File 'lib/rouge/cli.rb', line 221

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)


210
211
212
213
214
215
216
217
218
219
# File 'lib/rouge/cli.rb', line 210

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_lexerObject



289
290
291
292
293
294
295
# File 'lib/rouge/cli.rb', line 289

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

#inputObject



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

def input
  @input ||= input_stream.read
end

#input_streamObject



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

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

#lexerObject



297
298
299
# File 'lib/rouge/cli.rb', line 297

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

#lexer_classObject



277
278
279
280
281
282
283
# File 'lib/rouge/cli.rb', line 277

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

#raw_lexerObject



285
286
287
# File 'lib/rouge/cli.rb', line 285

def raw_lexer
  lexer_class.new(@lexer_opts)
end

#runObject



342
343
344
345
# File 'lib/rouge/cli.rb', line 342

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