Class: Haml::Exec::Generic

Inherits:
Object
  • Object
show all
Defined in:
lib/haml/exec.rb

Overview

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

Direct Known Subclasses

Haml

Instance Method Summary collapse

Constructor Details

#initialize(args) ⇒ Generic

Returns a new instance of Generic

Parameters:

  • args (Array<String>) —

    The command-line arguments

13
14
15
16
 
# File 'lib/haml/exec.rb', line 13

def initialize(args)
  @args = args
  @options = {:for_engine => {}}
end

Instance Method Details

#color(color, str) ⇒ String (protected)

Wraps the given string in terminal escapes causing it to have the given color. If terminal esapes aren’t supported on this platform, just returns the string instead.

Parameters:

  • color (Symbol) —

    The name of the color to use. Can be :red, :green, or :yellow.

  • str (String) —

    The string to wrap in the given color.

Returns:

  • (String) —

    The wrapped string.

155
156
157
158
159
160
161
162
163
 
# File 'lib/haml/exec.rb', line 155

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

#get_line(exception) ⇒ String (protected)

Finds the line of the source template on which an exception was raised.

Parameters:

  • exception (Exception) —

    The exception

Returns:

  • (String) —

    The line number

61
62
63
64
65
66
67
 
# File 'lib/haml/exec.rb', line 61

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

#parse

Parses the command-line arguments and runs the executable. This does not handle exceptions or exit the program.

See Also:

40
41
42
43
44
45
46
47
 
# File 'lib/haml/exec.rb', line 40

def parse
  @opts = OptionParser.new(&method(:set_opts))
  @opts.parse!(@args)

  process_result

  @options
end

#parse!

Parses the command-line arguments and runs the executable. Calls Kernel#exit at the end, so it never returns.

See Also:

22
23
24
25
26
27
28
29
30
31
32
33
34
 
# File 'lib/haml/exec.rb', line 22

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

#process_result (protected)

Processes the options set by the command-line arguments. In particular, sets @options[:input] and @options[:output] to appropriate IO streams.

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

110
111
112
113
114
115
116
117
118
119
120
121
122
 
# File 'lib/haml/exec.rb', line 110

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

#puts(*args) (protected)

Same as Kernel.puts, but doesn’t print anything if the --quiet option is set.

Parameters:

  • args (Array) —

    Passed on to Kernel.puts

141
142
143
144
 
# File 'lib/haml/exec.rb', line 141

def puts(*args)
  return if @options[:for_engine][:quiet]
  Kernel.puts(*args)
end

#puts_action(name, color, arg) (protected)

Prints a status message about performing the given action, colored using the given color (via terminal escapes) if possible.

Parameters:

  • name (#to_s) —

    A short name for the action being performed. Shouldn’t be longer than 11 characters.

  • color (Symbol) —

    The name of the color to use for this action. Can be :red, :green, or :yellow.

133
134
135
136
 
# File 'lib/haml/exec.rb', line 133

def puts_action(name, color, arg)
  return if @options[:for_engine][:quiet]
  printf color(color, "%11s %s\n"), name, arg
end

#set_opts(opts) (protected)

Tells optparse how to parse the arguments available for all executables.

This is meant to be overridden by subclasses so they can add their own options.

Parameters:

  • opts (OptionParser) 
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
 
# File 'lib/haml/exec.rb', line 76

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
    # Note that this is the preferred way to check for Windows, since
    # JRuby and Rubinius also run there.
    if RbConfig::CONFIG['host_os'] =~ /mswin|windows|mingw/i
      @options[:unix_newlines] = true
    end
  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}")
    exit
  end
end

#to_s ⇒ String

Returns A description of the executable

Returns:

  • (String) —

    A description of the executable

50
51
52
 
# File 'lib/haml/exec.rb', line 50

def to_s
  @opts.to_s
end