Class: Parser::Diagnostic::Engine

Inherits:
Object
  • Object
show all
Defined in:
lib/parser/diagnostic/engine.rb

Overview

Engine provides a basic API for dealing with diagnostics by delegating them to registered consumers.

Examples:

buffer      = Parser::Source::Buffer.new(__FILE__)
buffer.code = 'foobar'

consumer = lambda do |diagnostic|
  puts diagnostic.message
end

engine     = Parser::Diagnostic::Engine.new(consumer)
diagnostic = Parser::Diagnostic.new(
    :warning, :unexpected_token, { :token => 'abc' }, buffer, 1..2)

engine.process(diagnostic) # => "unexpected token abc"

Instance Attribute Summary (collapse)

Instance Method Summary (collapse)

Constructor Details

- (Engine) initialize(consumer = nil)

Returns a new instance of Engine

Parameters:



44
45
46
47
48
49
 
# File 'lib/parser/diagnostic/engine.rb', line 44

def initialize(consumer=nil)
  @consumer             = consumer

  @all_errors_are_fatal = false
  @ignore_warnings      = false
end

Instance Attribute Details

- (Boolean) all_errors_are_fatal

When set to true any error that is encountered will result in SyntaxError being raised.

Returns:

  • (Boolean) 


35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
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
 
# File 'lib/parser/diagnostic/engine.rb', line 35

class Diagnostic::Engine
  attr_accessor :consumer

  attr_accessor :all_errors_are_fatal
  attr_accessor :ignore_warnings

  ##
  # @param [#call(Diagnostic)] consumer
  #
  def initialize(consumer=nil)
    @consumer             = consumer

    @all_errors_are_fatal = false
    @ignore_warnings      = false
  end

  ##
  # Processes a `diagnostic`:
  #   * Passes the diagnostic to the consumer, if it's not a warning when
  #     `ignore_warnings` is set.
  #   * After that, raises {Parser::SyntaxError} when `all_errors_are_fatal`
  #     is set to true.
  #
  # @param [Parser::Diagnostic] diagnostic
  # @return [Parser::Diagnostic::Engine]
  # @see ignore?
  # @see raise?
  #
  def process(diagnostic)
    if ignore?(diagnostic)
      # do nothing
    elsif @consumer
      @consumer.call(diagnostic)
    end

    if raise?(diagnostic)
      raise Parser::SyntaxError, diagnostic
    end

    self
  end

  protected

  ##
  # Checks whether `diagnostic` should be ignored.
  #
  # @param [Parser::Diagnostic] diagnostic
  # @return [Boolean]
  #
  def ignore?(diagnostic)
    @ignore_warnings &&
          diagnostic.level == :warning
  end

  ##
  # Checks whether `diagnostic` should be raised as an exception.
  #
  # @param [Parser::Diagnostic] diagnostic
  # @return [Boolean]
  #
  def raise?(diagnostic)
    (@all_errors_are_fatal &&
        diagnostic.level == :error) ||
      diagnostic.level == :fatal
  end
end

- (#call(Diagnostic)) consumer

Returns:



35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
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
 
# File 'lib/parser/diagnostic/engine.rb', line 35

class Diagnostic::Engine
  attr_accessor :consumer

  attr_accessor :all_errors_are_fatal
  attr_accessor :ignore_warnings

  ##
  # @param [#call(Diagnostic)] consumer
  #
  def initialize(consumer=nil)
    @consumer             = consumer

    @all_errors_are_fatal = false
    @ignore_warnings      = false
  end

  ##
  # Processes a `diagnostic`:
  #   * Passes the diagnostic to the consumer, if it's not a warning when
  #     `ignore_warnings` is set.
  #   * After that, raises {Parser::SyntaxError} when `all_errors_are_fatal`
  #     is set to true.
  #
  # @param [Parser::Diagnostic] diagnostic
  # @return [Parser::Diagnostic::Engine]
  # @see ignore?
  # @see raise?
  #
  def process(diagnostic)
    if ignore?(diagnostic)
      # do nothing
    elsif @consumer
      @consumer.call(diagnostic)
    end

    if raise?(diagnostic)
      raise Parser::SyntaxError, diagnostic
    end

    self
  end

  protected

  ##
  # Checks whether `diagnostic` should be ignored.
  #
  # @param [Parser::Diagnostic] diagnostic
  # @return [Boolean]
  #
  def ignore?(diagnostic)
    @ignore_warnings &&
          diagnostic.level == :warning
  end

  ##
  # Checks whether `diagnostic` should be raised as an exception.
  #
  # @param [Parser::Diagnostic] diagnostic
  # @return [Boolean]
  #
  def raise?(diagnostic)
    (@all_errors_are_fatal &&
        diagnostic.level == :error) ||
      diagnostic.level == :fatal
  end
end

- (Boolean) ignore_warnings

When set to true warnings will be ignored.

Returns:

  • (Boolean) 


35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
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
 
# File 'lib/parser/diagnostic/engine.rb', line 35

class Diagnostic::Engine
  attr_accessor :consumer

  attr_accessor :all_errors_are_fatal
  attr_accessor :ignore_warnings

  ##
  # @param [#call(Diagnostic)] consumer
  #
  def initialize(consumer=nil)
    @consumer             = consumer

    @all_errors_are_fatal = false
    @ignore_warnings      = false
  end

  ##
  # Processes a `diagnostic`:
  #   * Passes the diagnostic to the consumer, if it's not a warning when
  #     `ignore_warnings` is set.
  #   * After that, raises {Parser::SyntaxError} when `all_errors_are_fatal`
  #     is set to true.
  #
  # @param [Parser::Diagnostic] diagnostic
  # @return [Parser::Diagnostic::Engine]
  # @see ignore?
  # @see raise?
  #
  def process(diagnostic)
    if ignore?(diagnostic)
      # do nothing
    elsif @consumer
      @consumer.call(diagnostic)
    end

    if raise?(diagnostic)
      raise Parser::SyntaxError, diagnostic
    end

    self
  end

  protected

  ##
  # Checks whether `diagnostic` should be ignored.
  #
  # @param [Parser::Diagnostic] diagnostic
  # @return [Boolean]
  #
  def ignore?(diagnostic)
    @ignore_warnings &&
          diagnostic.level == :warning
  end

  ##
  # Checks whether `diagnostic` should be raised as an exception.
  #
  # @param [Parser::Diagnostic] diagnostic
  # @return [Boolean]
  #
  def raise?(diagnostic)
    (@all_errors_are_fatal &&
        diagnostic.level == :error) ||
      diagnostic.level == :fatal
  end
end

Instance Method Details

- (Parser::Diagnostic::Engine) process(diagnostic)

Processes a diagnostic: * Passes the diagnostic to the consumer, if it’s not a warning when ignore_warnings is set. * After that, raises SyntaxError when all_errors_are_fatal is set to true.

Parameters:

Returns:

See Also:

  • ignore?
  • raise?


63
64
65
66
67
68
69
70
71
72
73
74
75
 
# File 'lib/parser/diagnostic/engine.rb', line 63

def process(diagnostic)
  if ignore?(diagnostic)
    # do nothing
  elsif @consumer
    @consumer.call(diagnostic)
  end

  if raise?(diagnostic)
    raise Parser::SyntaxError, diagnostic
  end

  self
end