class Haml::Exec::Generic

An abstract class that encapsulates the executable code for all three executables.

def color(color, str)

Returns:
  • (String) - The wrapped string.

Parameters:
  • str (String) -- The string to wrap in the given color.
  • color (Symbol) -- The name of the color to use.
def color(color, str)
  raise "[BUG] Unrecognized color #{color}" unless COLORS[color]
  # Almost any real Unix terminal will support color,
  # so we just filter for Windows terms (which don't set TERM)
  # and not-real terminals, which aren't ttys.
  return str if ENV["TERM"].nil? || ENV["TERM"].empty? || !STDOUT.tty?
  return "\e[#{COLORS[color]}m#{str}\e[0m"
end

def get_line(exception)

Returns:
  • (String) - The line number

Parameters:
  • exception (Exception) -- The exception
def get_line(exception)
  # SyntaxErrors have weird line reporting
  # when there's trailing whitespace,
  # which there is for Haml documents.
  return (exception.message.scan(/:(\d+)/).first || ["??"]).first if exception.is_a?(::SyntaxError)
  (exception.backtrace[0].scan(/:(\d+)/).first || ["??"]).first
end

def handle_load_error(err)

def handle_load_error(err)
  dep = err.message[/^no such file to load -- (.*)/, 1]
  raise err if @options[:trace] || dep.nil? || dep.empty?
  $stderr.puts <<MESSAGE
ed dependency #{dep} not found!
n "gem install #{dep}" to get it.
--trace for backtrace.
E
  exit 1
end

def initialize(args)

Parameters:
  • args (Array) -- The command-line arguments
def initialize(args)
  @args = args
  @options = {:for_engine => {}}
end

def open_file(filename, flag = 'r')

def open_file(filename, flag = 'r')
  return if filename.nil?
  flag = 'wb' if @options[:unix_newlines] && flag == 'w'
  File.open(filename, flag)
end

def parse

Other tags:
    See: #parse! -
def parse
  @opts = OptionParser.new(&method(:set_opts))
  @opts.parse!(@args)
  process_result
  @options
end

def parse!

Other tags:
    See: #parse -
def parse!
  begin
    parse
  rescue Exception => e
    raise e if @options[:trace] || e.is_a?(SystemExit)
    $stderr.print "#{e.class}: " unless e.class == RuntimeError
    $stderr.puts "#{e.message}"
    $stderr.puts "  Use --trace for backtrace."
    exit 1
  end
  exit 0
end

def process_result

so they can run their respective programs.
This is meant to be overridden by subclasses

to appropriate IO streams.
In particular, sets `@options[:input]` and `@options[:output]`
Processes the options set by the command-line arguments.
def process_result
  input, output = @options[:input], @options[:output]
  args = @args.dup
  input ||=
    begin
      filename = args.shift
      @options[:filename] = filename
      open_file(filename) || $stdin
    end
  output ||= open_file(args.shift, 'w') || $stdout
  @options[:input], @options[:output] = input, output
end

def puts(*args)

Parameters:
  • args (Array) -- Passed on to \{Kernel.puts}
def puts(*args)
  return if @options[:for_engine][:quiet]
  Kernel.puts(*args)
end

def puts_action(name, color, arg)

Parameters:
  • color (Symbol) -- The name of the color to use for this action.
  • name (#to_s) -- A short name for the action being performed.
def puts_action(name, color, arg)
  return if @options[:for_engine][:quiet]
  printf color(color, "%11s %s\n"), name, arg
end

def set_opts(opts)

Parameters:
  • opts (OptionParser) --
def set_opts(opts)
  opts.on('-s', '--stdin', :NONE, 'Read input from standard input instead of an input file') do
    @options[:input] = $stdin
  end
  opts.on('--trace', :NONE, 'Show a full traceback on error') do
    @options[:trace] = true
  end
  opts.on('--unix-newlines', 'Use Unix-style newlines in written files.') do
    @options[:unix_newlines] = true if ::Haml::Util.windows?
  end
  opts.on_tail("-?", "-h", "--help", "Show this message") do
    puts opts
    exit
  end
  opts.on_tail("-v", "--version", "Print version") do
    puts("Haml #{::Haml.version[:string]}")
    exit
  end
end

def to_s

Returns:
  • (String) - A description of the executable
def to_s
  @opts.to_s
end