view vendor/gems/coderay-1.0.0/bin/coderay @ 1082:997f6d7738f7 bug_531

In repo controller entry action, show the page for the file even if it's binary (so user still has access to history etc links). This makes it possible to use the entry action as the default when a file is clicked on

#!/usr/bin/env ruby
require 'coderay'

$options, args = ARGV.partition { |arg| arg[/^-[hv]$|--\w+/] }
subcommand = args.first if /^\w/ === args.first
subcommand = nil if subcommand && File.exist?(subcommand)
args.delete subcommand

def option? *options
  !($options & options).empty?
end

def tty?
  $stdout.tty? || option?('--tty')
end

def version
  puts <<-USAGE
CodeRay #{CodeRay::VERSION}
  USAGE
end

def help
  puts <<-HELP
This is CodeRay #{CodeRay::VERSION}, a syntax highlighting tool for selected languages.

usage:
  coderay [-language] [input] [-format] [output]
  
defaults:
  language   detect from input file name or shebang; fall back to plain text
  input      STDIN
  format     detect from output file name or use terminal; fall back to HTML
  output     STDOUT

common:
  coderay file.rb                      # highlight file to terminal
  coderay file.rb > file.html          # highlight file to HTML page
  coderay file.rb -div > file.html     # highlight file to HTML snippet

configure output:
  coderay file.py output.json          # output tokens as JSON
  coderay file.py -loc                 # count lines of code in Python file

configure input:
  coderay -python file                 # specify the input language
  coderay -ruby                        # take input from STDIN

more:
  coderay stylesheet [style]           # print CSS stylesheet
  HELP
end

def commands
  puts <<-COMMANDS
  general:
    highlight   code highlighting (default command, optional)
    stylesheet  print the CSS stylesheet with the given name (aliases: style, css)
  
  about:
    list [of]   list all available plugins (or just the scanners|encoders|styles|filetypes)
    commands    print this list
    help        show some help
    version     print CodeRay version
  COMMANDS
end

def print_list_of plugin_host
  plugins = plugin_host.all_plugins.map do |plugin|
    info = "  #{plugin.plugin_id}: #{plugin.title}"
    
    aliases = (plugin.aliases - [:default]).map { |key| "-#{key}" }.sort_by { |key| key.size }
    if plugin.respond_to?(:file_extension) || !aliases.empty?
      additional_info = []
      additional_info << aliases.join(', ') unless aliases.empty?
      info << " (#{additional_info.join('; ')})"
    end
    
    info << '  <-- default' if plugin.aliases.include? :default
    
    info
  end
  puts plugins.sort
end

if option? '-v', '--version'
  version
end

if option? '-h', '--help'
  help
end

case subcommand
when 'highlight', nil
  if ARGV.empty?
    version
    help
  else
    signature = args.map { |arg| arg[/^-/] ? '-' : 'f' }.join
    names     = args.map { |arg| arg.sub(/^-/, '') }
    case signature
    when /^$/
      exit
    when /^ff?$/
      input_file, output_file, = *names
    when /^f-f?$/
      input_file, output_format, output_file, = *names
    when /^-ff?$/
      input_lang, input_file, output_file, = *names
    when /^-f-f?$/
      input_lang, input_file, output_format, output_file, = *names
    when /^--?f?$/
      input_lang, output_format, output_file, = *names
    else
      $stdout = $stderr
      help
      puts
      puts "Unknown parameter order: #{args.join ' '}, expected: [-language] [input] [-format] [output]"
      exit 1
    end
    
    if input_file
      input_lang ||= CodeRay::FileType.fetch input_file, :text, true
    end
    
    if output_file
      output_format ||= CodeRay::FileType[output_file]
    else
      output_format ||= :terminal
    end
    
    output_format = :page if output_format.to_s == 'html'
    
    if input_file
      input = File.read input_file
    else
      input = $stdin.read
    end
    
    begin
      file =
        if output_file
          File.open output_file, 'w'
        else
          $stdout.sync = true
          $stdout
        end
      CodeRay.encode(input, input_lang, output_format, :out => file)
      file.puts
    rescue CodeRay::PluginHost::PluginNotFound => boom
      $stdout = $stderr
      if boom.message[/CodeRay::(\w+)s could not load plugin :?(.*?): /]
        puts "I don't know the #$1 \"#$2\"."
      else
        puts boom.message
      end
      # puts "I don't know this plugin: #{boom.message[/Could not load plugin (.*?): /, 1]}."
    rescue CodeRay::Scanners::Scanner::ScanError  # FIXME: rescue Errno::EPIPE
      # this is sometimes raised by pagers; ignore [TODO: wtf?]
    ensure
      file.close if output_file
    end
  end
when 'li', 'list'
  arg = args.first && args.first.downcase
  if [nil, 's', 'sc', 'scanner', 'scanners'].include? arg
    puts 'input languages (Scanners):'
    print_list_of CodeRay::Scanners
  end
  
  if [nil, 'e', 'en', 'enc', 'encoder', 'encoders'].include? arg
    puts 'output formats (Encoders):'
    print_list_of CodeRay::Encoders
  end
  
  if [nil, 'st', 'style', 'styles'].include? arg
    puts 'CSS themes for HTML output (Styles):'
    print_list_of CodeRay::Styles
  end
  
  if [nil, 'f', 'ft', 'file', 'filetype', 'filetypes'].include? arg
    puts 'recognized file types:'
    
    filetypes = Hash.new { |h, k| h[k] = [] }
    CodeRay::FileType::TypeFromExt.inject filetypes do |types, (ext, type)|
      types[type.to_s] << ".#{ext}"
      types
    end
    CodeRay::FileType::TypeFromName.inject filetypes do |types, (name, type)|
      types[type.to_s] << name
      types
    end
    
    filetypes.sort.each do |type, exts|
      puts "  #{type}: #{exts.sort_by { |ext| ext.size }.join(', ')}"
    end
  end
when 'stylesheet', 'style', 'css'
  puts CodeRay::Encoders[:html]::CSS.new(args.first).stylesheet
when 'commands'
  commands
when 'help'
  help
else
  $stdout = $stderr
  help
  puts
  if subcommand[/\A\w+\z/]
    puts "Unknown command: #{subcommand}"
  else
    puts "File not found: #{subcommand}"
  end
  exit 1
end