# Class: Haml::Exec::Generic

Inherits:
  Object
  - Object
  - Haml::Exec::Generic
  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

- #color(color, str) ⇒ String protected

  Wraps the given string in terminal escapes causing it to have the given color.

- #get_line(exception) ⇒ String protected

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

- #initialize(args) ⇒ Generic constructor

  A new instance of Generic.

- #parse

  Parses the command-line arguments and runs the executable.

- #parse!

  Parses the command-line arguments and runs the executable.

- #process_result protected

  Processes the options set by the command-line arguments.

- #puts(*args) protected

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

- #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.

- #set_opts(opts) protected

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

- #to_s ⇒ String

  A description of the executable.

## 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:

- #parse!

    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:

- #parse

    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